Pattern Dao in Java

Il pattern DAO è usato per separare la logica di business dalla logica di acceso ai dati. Infatti, i componenti della logica di business non dovrebbero mai accedere direttamente al database: questo comporterebbe scarsa manutenibilità. Solo gli oggetti previsti dal pattern Dao possono accedervi.  Inoltre, se dovessimo modificare il tipo di memoria persistente utilizzata, o anche passare da Oracle a MySql per esempio, non sarà necessario stravolgere il codice della nostra applicazione, ma basterà modificare i DAO utilizzati.

Continua a leggere

HtmlTags Titoli, Paragrafi e Testo a capo

HTML è nato per la mostrare contenuti ipertestuali, per questo la maggior parte dei tags si riferiscono all’organizzazione dei testi, testi che saranno composti da titoli, paragrafi, etc.

Per creare un paragrafo esiste il tag <p></p>.  In una pagina html, se ne possono inserire più di uno. Tra un paragrafo e l’altro c’è una riga di spazio.

Esempio:

<!DOCTYPE html>
<html>
<body>

<h1>Titolo<h1>
<h2>Sotto Titolo</h2>
<p>questo è un esempio di paragrafo</p>
<p>Sul sito Coding Creativo troverete tanti esempi ed esercizi su scratch</p>
<p>bla bla bla bla bla bla bla bla bla blabla bla bla bla blabla bla bla bla blabla bla bla bla blabla bla bla bla blabla bla bla bla bla</p>

</body>
</html>

Otteniamo:

Continua a leggere

Merge Sort

Il Merge Sort,  inventato da John Von Neumann nel 1945, è molto simile al Quick Sort, ma  l’elemento pivot, in questo caso, viene scelto sempre nel centro.

L’idea principale è che, avendo due array ordinati, è molto semplice fonderli in un unico array ordinato. Inoltre,  un’array di un elemento  è sempre ordinato.

Unendo questi concetti,  si ha un algoritmo che, dopo aver suddiviso ricorsivamente l’array iniziale A in n sotto-array, costituiti da un solo elemento,  fonde i sotto-array e fino a ottenere  un’unico array ordinato.

Continua a leggere

Quick Sort

L’algoritmo Quick Sort, ideato da Charles Antony Richard Hoare nel 1960, è forse il più famoso algoritmo di ordinamento, ed ha, nel caso medio, le migliori prestazioni tra gli algoritmi basati su confronto. 

Adotta una strategia di tipo divide et impera, ossia divide il problema in tanti sotto problemi, fino a raggiungere dei sotto problemi facilmente risolvibili.

Questo approccio è conveniente solo se lo sforzo per ricomporre le soluzioni dei sotto problemi ed ottenere la soluzione del problema iniziale, è inferiore allo sforzo per risolvere il problema nella sua interezza.

Continua a leggere

Insert Sort

L’algoritmo di ordinamento InsertSort (ordinamento diretto) nasce dal concetto che per ordinare un array ordinato è sufficiente costruirne uno nuovo ordinato, inserendo gli elementi al posto giusto da subito. Nella pratica, non è necessario crearne uno nuovo ma dividere quello esistente in due parti, una ordinata e l’altra no.

Esempio:

Vogliamo ordinare l’insieme A = {5, 3, 2, 1, 4}.

Iterazione 1. A = {5 | 2, 3, 1, 4} → A = {2, 5 | 3, 1, 4}

Iterazione 2. A = {2, 5 | 3, 1, 4} → A = {2,3, 5 | 1, 4}

Iterazione 3. A = {2, 3, 5 | 1, 4} → A = {1, 2, 3, 5 | 4}

Iterazione 4. A = {1, 2, 3, 5 | 4} → A = {1, 2, 3,4, 5}

Codificando l’Insert Sort abbiamo:

Continua a leggere

Bubble Sort

L’algoritmo Bubble Sort  è basato sullo scambio di elementi adiacenti. Ogni coppia di elementi adiacenti viene comparata e invertita di posizione, se il primo è più grande del secondo. Quando questa operazione è stata ripetuta  per tutti gli elementi, si ha che l’elemento  più grande si trova in fondo, a destra, della sequenza considerata.

Dopodiché, si ripete questa procedura sugli elementi rimanenti, togliendo elemento più grande trovato prima.

L’algoritmo, iterando più volte  questi passaggi, fino a quando non ci saranno scambi. Allora l’array ottenuto sarà ordinato.

Continua a leggere

Selection Sort

L’algoritmo Selection Sort è quello più semplice, quello che seguirebbe istintivamente qualsiasi persona. Da un gruppo da ordinare seleziona il più piccolo, lo toglie,  e lo inserisce nella giusta posizione in un gruppo ordinato.

In termini un po’ più tecnici, l’algoritmo ripete per n volte una procedura in grado di selezionare alla i-esima iterazione l’elemento più piccolo nell’insieme e di scambiarlo con l’elemento che in quel momento occupa la posizione i. 

Ossia, alla prima iterazione verrà selezionato l’elemento più piccolo dell’intero insieme e sarà scambiato con quello che occupa la prima posizione; alla seconda iterazione sarà selezionato il secondo elemento più piccolo dell’insieme ridotto (cioè costituito dagli elementi {a2,a3,…,an} ) e sarà scambiato con l’elemento che occupa la seconda posizione, e così via fino ad aver collocato nella posizione corretta tutti gli n elementi.

Continua a leggere

Test Java Online

1. Quale delle seguenti affermazioni sul costruttore di default è vera?

 
 
 

2. Quali delle seguenti affermazioni relativa alle Transazioni sono vere?

a) I task contenuti in una transazione hanno priorità diverse in base all’importanza dell’operazione che effettuano.
b) Le transazioni non garantiscono la consistenza del dato in caso di crash del sistema che ospita il software
c) Una transazione è un insieme di operazioni che deve essere portata a termine nella sua interezza.
d) I dati diverranno persistenti solamente nel momento in cui tutti i task contenuti nella transazione saranno terminati.

 
 
 
 

3. Quale sarà l’output

class output {
        public static void main(String args[])
        {
           String s1 = "Hello World";
           String s2 = s1.substring(0 , 4);
           System.out.println(s2);
        }
   }
 
 
 
 

4. Considerando il seguente frammento di codice:

private Integer fieldOne;
private int fieldTwo;

Con quale valore verranno inizializzate le variabili?

 
 
 
 

5. La parola chiave final, applicata ad un metodo, cosa indica?

 
 
 

6. Quale sarà l’output?

class s1 extends Thread
{ 
    public void run() 
    { 
        for(int i = 0; i < 3; i++) 
        { 
            System.out.println("A"); 
            System.out.println("B"); 
        } 
    } 
} 
class Test120 extends Thread 
{ 
    public void run() 
    { 
        for(int i = 0; i < 3; i++) 
        { 
            System.out.println("C"); 
            System.out.println("D"); 
        } 
    } 
    public static void main(String args[]) 
        { 
        s1 t1 = new s1(); 
        Test120 t2 = new Test120(); 
        t1.start(); 
        t2.start(); 
    } 
}

 

 
 
 
 

7. Un Ejb Session può essere deployato su Tomcat

 
 

8. Quale sarà l’output?

 

public class X 
{  
    public static void main(String [] args) 
    {
        try 
        {
            badMethod();  
            System.out.print("A");  
        } 
        catch (RuntimeException ex) /* Line 10 */
        { 
            System.out.print("B"); 
        } 
        catch (Exception ex1) 
        { 
            System.out.print("C"); 
        } 
        finally 
        {
            System.out.print("D"); 
        } 
        System.out.print("E"); 
    } 
    public static void badMethod() 
    { 
        throw new RuntimeException(); 
    } 
}
 
 
 
 

9. Se un insieme di metodi di uno o più bean ha definiti i seguenti attributi per le transazioni:
Metodo-1 -> Supports

Metodo-2 -> Required

Metodo-3 -> NotSupported

Metodo-4 -> RequiresNew
nei diagrammi che seguono, una freccia indica che il metodo sulla sinistra chiama quello sulla destra, e tra parentesi è indicata la transazione all’interno della quale viene eseguito (‘No Tx’ indica che il metodo viene eseguito senza transazioni). Quale dei seguenti diagrammi si adatta agli attributi elencati sopra ?

 
 
 
 

10. Considerando il seguente frammento di codice:

[java]

public class SuperInheritance {
public void print() {
System.out.print(“super”);
}

private void printHello() {
System.out.println(“hello”);
}
}

class Inheritance extends SuperInheritance {
@Override
public void print() {
System.out.println(“this”);
}

public static void main(String[] args) {
Inheritance inheritance = new Inheritance();
inheritance.print();
inheritance.printHello();
}

}

[/java]

Quale output verrà prodotto?

 
 
 

11. Quali delle seguenti affermazioni relative all’istruzione ‘return’ sono vere?

a) L’istruzione return viene utilizzata solo nei metodi statici.
b) L’istruzione return è obbligatoria nei metodi che non hanno void come tipo di ritorno
c) L’istruzione return si può usare in qualsiasi metodo per controllare il flusso di esecuzione.
d) L’istruzione return è obbligatoria in tutti i metodi.

 
 
 
 

12. Quale sarà l’output

class output {
        public static void main(String args[])
        { 
           String s1 = "Hello i love java";
           String s2 = new String(s1);
           System.out.println((s1 == s2) + " " + s1.equals(s2));
        }
    }
 
 
 
 

13. Quale sarà l’output

for(int i = 0; i < 3; i++) 
{ 
    switch(i) 
    { 
        case 0: break; 
        case 1: System.out.print("one "); 
        case 2: System.out.print("two "); 
        case 3: System.out.print("three "); 
    } 
} 
System.out.println("done")
 
 
 
 

14. Un ear può essere deployato in tomcat?

 
 

15.

Una classe astratta deve avere per avere per forza almeno un metodo astratto?
 
 

Question 1 of 15