Q17

Given:

import java.util.Scanner;

  public class Painting {

     public static void main(String[] args) {

          String input = "Pastel, *Enamel, Fresco, *Gouache";

          Scanner s = new Scanner(input);

          s.useDelimiter(",\\s*");

          while (s.hasNext()) {

                System.out.println(s.next());

          }

     }

  }

 

 What is the result?

 A.

 Paste1

 Ename1

 Fresco

 Gouache

 B.

 Paste1

 *Ename1

 Fresco

 *Gouache

 C.

 Pastel

 Ename1

 Fresco

 Gouache

 D.

 Pastel

 Ename1, Fresco

 Gouache

La risposta è B

Scanner è un semplice scanner di testo in grado di parsare tipi primitivi o String utilizzando le espressioni regolari.

Uno Scanner spezza l’ingresso in pezzi (token) a seconda del delimitatore stabilito, che di default è lo spazio.

I token risultanti possono poi essere convertiti in tipi diversi utilizzando i vari metodi next messi a disposizione.

Il delimitatore può essere cambiato tramite il metodo useDelimitator.

L’espressione usate nel delimitatore : è ",\\s*" .

\s equivale a [ \t\n\r]

[ \t] spazi e tabulazioni

\n  fine riga

\r ritorno a capo (CR)

* indica zero o più occorrenze (di un carattere o di un gruppo di caratteri)

Quindi s.useDelimiter(",\\s*"); va letta come :

Utilizza come nuovo delimitatore la virgola ( , ) seguita da un numero qualunque (anche zero) di spazi, tabulazioni fine riga o ritorni a capo. In pratica è un modo per includere ogni virgola della stringa. Nel token quindi finisce tutto ciò che non è la virgola che viene stampato quando si usa il metodo next.

Riferimenti:

http://docs.oracle.com/javase/1.5.0/docs/api/java/util/Scanner.html
http://docs.oracle.com/javase/1.5.0/docs/api/java/util/Scanner.html#useDelimiter(java.lang.String)
http://blog.chalda.it/guida-alla-sintassi-delle-espressioni-regolari-217.html

 

Q16

How many Threads are created when passing task to an Executor instance?

 

A.

A new Thread is used for each task.

B.

A number of Threads equal to the number of CPUs Is used to execute tasks.

C.

A single Thread Is used to execute all tasks.

D.

A developer-defined number of Threads is used to execute tasks.

E.

A number of Threads determined by system load is used to execute tasks.

F.

The method used to obtain the Executor determines how many Threads are used to execute tasks.

La risposta è F.

Executor è la più semplice delle interfacce definite nel pacchetto java.util.concurrent, che serve a realizzare la programmazione concorrente. Fornisce un singolo metodo, execute,  progettato allo scopo di rimpiazzare la classica sintassi di basso livello per la creazione di un thread .

            (new Thread (r)) start ();

con

            e.execute (r);

Con r un oggetto Runnable ed e un Executor.

Tuttavia, la definizione di execute è meno specifica. Se il linguaggio di basso livello crea un nuovo thread e lo lancia immediatamente Executor può invece utilizzare un thread già esistente per eseguire r, crearne uno nuovo e lanciarlo come nella sintassi di basso livello o anche mettere r in una coda in attesa che un thread di lavoro diventi disponibile.

Riferimenti:

http://docs.oracle.com/javase/tutorial/essential/concurrency/exinter.html

Q15

Which type of ExecutorService supports the execution of tasks after a fixed delay?

 

A.

DelayedExecutorService

 

B.

ScheduledExecutorService

C.

TimedExecutorService

D.

FixedExecutorService

E.

FutureExecutorService

 

Risposta B.

La java.util.concurrent.ScheduledExecutorService è una ExecutorService che può pianificare le attività da eseguire con un certo ritardo oppure che può eseguirle più volte con un intervallo tra le varie esecuzioni. Le operazioni vengono eseguite in modo asincrono da un thread di lavoro e non dal thread che gestisce il task della ScheduledExecutorService stessa.

Riferimenti :

http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/ScheduledExecutorService.html

http://tutorials.jenkov.com/java-util-concurrent/scheduledexecutorservice.html

 

 

Q14

Given:

import java.util.*;

public class Flimmer  implements Pinkable {

             List <Tagger> t = new ArrayList<Tagger>();

       }

 

public class Flommer extends Flimmer {

             String s = "hey" ;

       }

 

public class Tagger implements Glommer {

       void doStuff(){ String s ="yo" ;}

}

public interface Glommer {}

public interface Pinkable {}

Which two statements concerning the OO concepts “is-a” and “has-a” are true?

A.

Flimmer is-a Glommer.

B.

Flommer has-a String.

C.

Tagger has-a Glommer.

D.

Flimmer is-a ArrayList.

E.

Tagger has-a doStuff().

F.

Tagger is-a Glommer.

 

 

La risposta è EF.

Nella programmazione orientata agli oggetti (e in generale nella rappresentazione della conoscenza) is-a indica una relazione dove una classe A è sottoclasse di una classe B (e B è superclasse di A) .

A is-a B indica che A è sotto tipo di B.

Un altro modo di specificare questo concetto è dire ogni oggetto che soddisfa le specifiche di A soddisfa anche le specifiche di B , perché le specifiche di B sono più leggere di quelle di A.

Invece has-a indica che un oggetto appartiene ad un altro oggetto. In Java ad esempio un attributo appartiene ad una classe e quindi :

A has-a B indica che la classe A ha un attributo B.

Ad esempio consideriamo queste tre classi :

public class Superclasse {}

public class Sottoclasse extends Superclasse{  }

public class Classe {

int attributo;

}

Possiamo scrivere :

·         Sottoclasse     is-a      Superclasse

·         Classe             has-a    attributo

Quindi :

A.

Flimmer is-a Glommer. NO

Stiamo dicendo che Flimmer è sotto tipo di Glommer ma non è vero perchè tra i due oggetti non c'è relazione.

Sarebbe vero dire Flimmer is-a Pinkable perchè in effetti Flimmer  implementa Pinkable e quindi ne è un sotto tipo.

B.

Flommer has a String. NO

Sarebbe giusto dire Flommer has-a s (che è di tipo String)

C.

Tagger has-a Glommer. NO

Per essere vero Tagger dovrebbe avere Glommer come attributo.

D.

Flimmer is-a ArrayList. NO

Flimmer non è certo un sotto tipo del tipo ArrayList!

E.

Tagger has a doStuff() OK

Questo è vero perchè in effetti Tagger possiede il metodo doStuff().

F.

Tagger is-a Glommer. OK

Questo è vero perchè Tagger è un sotto tipo di Glommer. Infatti Glommer è una interfaccia e Tagger la implementa.

Riferimenti:

http://www.desy.de/gna/html/cc/Tutorial/node6.htm#SECTION00614000000000000000

Q13

Given the Greetings.properties file, containing:

HELLO_MSG = Hello, everyone!

GOODBYE_MSG = Goodbye everyone!

 

And given:

public class ResourceApp {

       public void loadResourceBundle() {

             ResourceBundle resource = ResourceBundle.getBundle("Greetings",Locale.US);

             System.out.println(resource.getObject(1));

       }

       public static void main(String[] args) {

             new ResourcesApp().loadResourceBundle();

       }

}

What is the result?

A.

Compilation fails

B.

HELLO_MSG

C.

GOODGYE_NSG

D.

Hello, everyone!

E.

Goodbye everyone!

La risposta è A.

Infatti per come è scritto quel codice non compila per due motivi :

1)      Il metodo getObject() di ResourceBundle accetta solo String.

2)      Nel new ResourcesApp() c’è un errore infatti il tipo ResourcesApp non è definito.

Se invece si considera questo altro codice, in cui ResourcesApp si sostituisce con ResourceApp (senza la s) e l’argomento al metodo getObject si cambia da 1 ad “1” si ha una corretta compilazione:

import java.util.Locale;

import java.util.ResourceBundle;

 

public class ResourceApp {

       public void loadResourceBundle() {

             ResourceBundle resource = ResourceBundle.getBundle("Greetings",Locale.US);

             System.out.println(resource.getObject("1"));

       }

       public static void main(String[] args) {

             new ResourcesApps().loadResourceBundle();

       }

}

Per testare questo codice va creato un file di proprietà Greetings :

 

con il seguente codice :

HELLO_MSG = Hello, everyone!

GOODBYE_MSG = Goodbye everyone!

 

In questo caso il codice restituisce una eccezione a Runtime perché nel file di properties non esiste una risorsa con chiave “1”:

Exception in thread "main" java.util.MissingResourceException: Can't find resource for bundle java.util.PropertyResourceBundle, key 1

Il codice viene eseguito correttamente invece nel caso di richiamo di una chiave esistente , ad esempio  HELLO_MSG :

import java.util.Locale;

import java.util.ResourceBundle;

public class ResourceApp {

       public void loadResourceBundle() {

             ResourceBundle resource = ResourceBundle.getBundle("Greetings",Locale.US);

             System.out.println(resource.getObject("HELLO_MSG"));

       }

       public static void main(String[] args) {

             new ResourceApp().loadResourceBundle();

       }

}

in questo caso l’uscita è : Hello, everyone!.

Riferimenti:

http://docs.oracle.com/javase/6/docs/api/java/util/ResourceBundle.html#getObject(java.lang.String)

Q12

Given:

public interface Vehicle {

       public void start();

       public void stop();

}

 

public interface Motorized {

       public void stop();

       public void slow();

}

 

public class Car implements Vehicle,Motorized {

       public void start(){};

       public void stop(){};

       public void slow(){};

}

 

What is the result of invoking Car’s stop method?

 

A.

Both vehicles and Motorized’s stop methods are invoked.

B.

Vehicles stop method is invoked.

C.

Motorized’s stop method is invoked.

 

D.

The implementation of the Car’s stop determines the behavior.

E.

Compilation fails.

 

La Risposta è D

Infatti per definizione i metodi non possono essere implementati nelle interfacce ma sono nelle classi. Quindi l’unica implementazione possibile è dentro la classe Car.