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. Si può accedere a una variabile non statica da un metodo statico?

 
 

2. Le interfacce devono essere estese o implementate?

 
 

3. Quali delle seguenti affermazioni relativa agli Web Services sono vere?

a) Un web service scritto in java potrà essere richiamato solo da un client java.
b) I Web service presentano performance inferiori rispetto ad altri metodi di comunicazione utilizzabili in rete.
c) I Web service utilizzano il protocollo http.

 
 
 

4. Qual’è l’output di questo programma?

public class Test 
{
    public int aMethod()
    {
        static int i = 0;
        i++;
        return i;
    }
    public static void main(String args[])
    {
        Test test = new Test();
        test.aMethod();
        int j = test.aMethod();
        System.out.println(j);
    }
}
 
 
 
 

5. Quale sarà l’output

interface calculate {
            int VAR = 0;
            void cal(int item);
        }
        class display implements calculate {
            int x;
          public  void cal(int item) {
                if (item<2)
                    x = VAR;
                else
                    x = item * item;            
            }
        }
 class interfaces {
 
            public static void main(String args[]) {
                display[] arr=new display[3];
 
               for(int i=0;i<3;i++)
               arr[i]=new display();
               arr[0].cal(0);    
               arr[1].cal(1);
               arr[2].cal(2);
               System.out.print(arr[0].x+" " + arr[1].x + " " + arr[2].x);
            }
        }
 
 
 
 

6. Quale sarà l’output?

 class output {
        public static void main(String args[])
        {             String s = "Hello World";
             int i = s.indexOf('o');
             int j = s.lastIndexOf('l');
             System.out.print(i + " " + j);
 
        }
   }
 
 
 
 

7. Una interfaccia può estendere un’altra interfaccia

 
 

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

 
 
 

9. Quale sarà l’output?

public class If1 
{
    static boolean b;
    public static void main(String [] args) 
    {
        short hand = 42;
        if ( hand < 50 && !b ) /* Line 7 */
            hand++;
        if ( hand > 50 );     /* Line 9 */
        else if ( hand > 40 ) 
        {
            hand += 7;
            hand++;    
        }
        else
            --hand;
        System.out.println(hand);
    }
}
 
 
 
 

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

 
 
 

11.

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

12. Quale sarà l’output del programma?

class PassA 
{
    public static void main(String [] args) 
    {
        PassA p = new PassA();
        p.start();
    }

    void start() 
    {
        long [] a1 = {3,4,5};
        long [] a2 = fix(a1);
        System.out.print(a1[0] + a1[1] + a1[2] + " ");
        System.out.println(a2[0] + a2[1] + a2[2]);
    }

    long [] fix(long [] a3) 
    {
        a3[1] = 7;
        return a3;
    }
}
 
 
 
 

13. Quale delle seguenti affermazioni, riferita ad una classe anonima, è vera?

 
 
 

14. Considerando il seguente frammento di codice:

private Integer fieldOne;
private int fieldTwo;

Con quale valore verranno inizializzate le variabili?

 
 
 
 

15. Cos’è l’overloading di un metodo?

 
 
 

Question 1 of 15

Esempio di WebServices con Annotation – Client SOAPUI

Per creare un Web Services esistono vari modi.
In questo esempio useremo l’annotation @WebService. In particolare avremo un web services con due operazioni:

  • public String prova(String msg)
  • public Persona getPerson(String codFisc)

Il primo prende in input una stringa e restituisce un’altra stringa.
Il secondo in input  sempre una stringa ma restituisce un oggetto di tipo Persona.
Per invocarli useremo il tool SOAPUI.

Tools Usati

  • Eclipse Mars 2
  • Wildfly 10
  • SoapUI

Continua a leggere