Rover in Java con grafica 2D

Ecco il progetto del Rover con l'aggiunta dell'interfaccia grafica 2D

Link per scaricare il file jar:
DOWNLOAD

Codice Sorgente:

[Main.java]

import java.awt.Color;
import java.awt.Graphics;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JButton;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import javax.swing.JLabel;

class MyCanvas extends JComponent {

    public void paint(Graphics g) {
        Main m = new Main();
        // Disegna marte
        g.setColor(new Color(255,128,0));
        g.fillRect(0, 0, 600, 600);
        // Disegna matrice
        for(int i=0;i<10;i++){
              for(int j=0;j<10;j++){
                  if(m.n[i][j]==true){
                     g.setColor(Color.GREEN);
                     g.fillRect(i*60, j*60, 60,60);
                  }
              }
          }
    }
}

public class Main {
   
    static int m[][] = new int[10][10];
    static boolean n[][] = new boolean[10][10];
   
    public static void main(String[] a) {
        Rover analista = new Rover();
       
        analista.inizializzare(m, n);
        analista.controllare(m, n);
        analista.stampare(m, n);

        JFrame window = new JFrame();
        window.setTitle("Rover v1");
        window.setResizable(false);
        window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        window.setBounds(30, 30, 600, 700);
        window.getContentPane().setLayout(null);
        it.simoleoleo.MyCanvas myCanvas = new MyCanvas();
        myCanvas.setBounds(0, 0, 602, 661);
        window.getContentPane().add(myCanvas);
       
        JButton btnGeneraScan = new JButton("Ri-Genera scan");
        btnGeneraScan.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseClicked(MouseEvent arg0) {
                // Evento genera
                analista.inizializzare(m, n);
                analista.controllare(m, n);
                analista.stampare(m, n);
                window.repaint();
            }
        });
        btnGeneraScan.setBounds(228, 613, 140, 37);
        window.getContentPane().add(btnGeneraScan);
       
        JLabel lblCreditiLeonardoPangoni = new JLabel("Team simoleoleo.blogspot.it");
        lblCreditiLeonardoPangoni.setBounds(10, 647, 160, 14);
        window.getContentPane().add(lblCreditiLeonardoPangoni);
        window.setVisible(true);
    }
}

[Rover.java]

package it.simoleoleo;

public class Rover {
    public void controllare (int m[][],boolean n[][]){
    for (int i = 0; i < m.length; i++){
            for (int j=0;j<m.length;j++){
                if(m[i][j]>50){
                    n[i][j]=true;
                }
            }  
    }
}

    public void stampare(int m[][], boolean n[][]) {
        System.out.println("***********************");
        for (int i = 0; i < m.length; i++) {
            for (int j = 0; j < m.length; j++) {
                System.out.print(n[i][j] + " ");
                if (j == 9) {
                    System.out.println(" ");
                }
            }
        }
        System.out.println("***********************");
    }

    public void inizializzare(int m[][], boolean n[][]) {
        for (int i = 0; i < m.length; i++) {
            for (int j = 0; j < m.length; j++) {
                m[i][j] = (int) (Math.random() * 100);
                n[i][j] = false;
            }
        }
    }
}

Rover di Marte in Java

[Main.java]



public static void main(String[] args) {
        Rover analista=new Rover();
        int m[][]=new int [10][10];
        boolean n[][]=new boolean [10][10];
        analista.inizializzare(m, n);
        analista.controllare(m, n);
        analista.stampare(m, n);
    }
  
}

______________________________________________

[Rover.java]

public class Rover {
public void controllare (int m[][],boolean n[][]){
    for (int i=0;<m.length;i++){
            for (int j=0;j<m.length;j++){
                if(m[i][j]>50){
                    n[i][j]=true;
                }
            }   
    }
}
public void stampare (int m[][],boolean n[][]){
for (int i=0;i<m.length;i++){
for (int j=0;j<m.length;j++){
System.out.print(n[i][j]+" ");
if(j==9){
System.out.println(" ");
}
}
}
}
public void inizializzare (int m[][],boolean n[][]){
for (int i=0;i<m.length;i++){
for (int j=0;j<m.length;j++){
m[i][j]=(int) (Math.random()*100);
n[i][j]=false;
}
}
}
}

ALCUNI RECORD DEGLI ANIMALI

Il pesce più grande: lo squalo balena, che raggiunge i 18m di lunghezza e le 20 tonnellate di peso.
Il rettile più grande: Il coccodrillo marino, che ragiunge gli 8m di lunghezza e le 2 tonnellate di peso.
Il mammifero più grande (e anche probabilmente il più grande animale mai apparso sulla terra): la balenottera azzurra, che misura fino a 33m di lunghezza e pesa anche 130 tonnellate, come 20 elefanti o 180 mucche (il suo cuore è grande come una mucca e la sua aorta è così grande che un uomo ci potrebbe nuotare dentro).
Il ruminante più piccolo: il kancil malese, che misura appena 25cm di altezza e 47cm di lunghezza.
L'uccello più piccolo: il colibrì, lungo appena 5cm per un peso di 1,6g.
Il serpente più lungo: il pitone reticolato, con la misura massima di 10m.
La lucertola più grande: il drago di komodo, che arriva ad una lunghezza di 3,5m per un peso di 130Kg.
Il naso più lungo: quello dell'elefante africano, la cui proboscide può misurare sui 2,5m.
Le corna più lunghe: quelle del muflone di marco polo che, avvolte a spirale, arrivano a 190cm.
Le corna più pesanti: quelle dell'alce, che pesano 45kg.
Il collo più lungo: quello della giraffa che misura 2m ed è composto da sole 7 vertebre lunghe però 27cm l'una.
Le orecchie più grandi: quelle dell'elefante africano, ciascuna ha la superficie di 4mq ed un diametro di 1,80m.
I peli più grossi: il record è conteso tra i baffi del tricheco e i peli della coda dell'elefante, entrambi hanno un diametro alla base di 3mm.
I peli più lunghi: quelli del bue muschiato della groenlandia, la cui pelliccia è formata da peli lunghi 60-90cm.
Il becco più lungo: quello del pellicano australiano, che misura 50cm.
Il becco più colorato: quello del tucano arcobaleno, che ha ben 5 colori.
Le lingue più elastiche: - il formichiere può estrarre una lingua di 60cm.
- la giraffa e l'okapi possono estrarre 2 lingue rispettivamente di 50 e 35cm.
- il camaleonte può estrarre una lingua lunga come il suo corpo.
- i picchi hanno una lingua che può sporgere dal becco di 10cm.
L'occhio più grande: quello del calamaro gigante, di 40cm di diametro.
Gli occhi più numerosi: i ragni possono averne fino a otto.
L'animale più lento: - La lumaca carnivora si muove ad una velocità di 0,90m/h, impiega 46 giorni per percorrere 1km.
- il bradipo si trascina sul ventre ad una velocità di 158m/h, impiega ben 6h e 30 minuti per percorrere 1km.
I record di salto: - tra i mammiferi il record è detenuto dal puma, con un salto di 7m in altezza senza rincorsa.
- il record di salto in lungo, con una misura di 15m, è conteso tra la tigra e il leopardo.
- il record assoluto appartiene alla pulce con un salto di 25cm in altezza e 35cm in lunghezza. Un uomo per eguagliare un tale risultato dovrebbe saltare 290m in altezza e 400m in lunghezza.

MajoLinux

Il nostro Team insieme ai tecnici di laboratorio e al professor Marco Palladino sta lavorando per portare Linux nel nostro istituto, il liceo scientifico Ettore Majorana di Moncalieri. Useremo Linux Mint o Linux Xubuntu, il sistema operativo più votato dagli utenti sarà quello finale. Questi due sistemi operativi montano tutti e due il Linux kernel 3.13 e sono pressochè identiche. Linux Mint è il piu usato fra gli utenti Linux e ha un parco software piu ricco mentre Xubuntu punta alla leggerezza e alle performance. Aggiungeremo oltre al software di base anche:

• Java Runtime Environment 7; Java Development Kit 7
• NetBeans IDE 
• Eclipse Luna
• Android Studio
• Geany
• Scratch
• Arduino IDE
• Geogebra

Per chi volesse approfondire:

Linux Mint webpage http://linuxmint.com/

Linux Xubuntu webpage  http://www.xubuntu.org/

Screenshots:
 

Recensione blogspot

Il sito blogspot, utilizato da noi, é uno dei migliori siti di preprazione di blog. Il programma ti da la possibilità di modificare\creare un blog a proprio piacimento utilizzando delle impostazioni semplici da imparare e molto veloci. Inoltre ti dà la possibilità di creare più blog, senza causare molte difficoltà nella gestione, alla pagina iniziale, infatti, ti viene subito dichiarato il numero di visualizzazioni ed il numero di post pubblicati su quest'ultimo.
Inoltre questo programma ti dà una grande varietà di impostazioni grafiche sia la possibilità di modificare file di blog salvarlo modificarlo successivamente e se non si è ottenuto un risultato soddisfacente ricaricare il vecchio design.
Blogspot ti offre anche un applicazione per creare post da cellulare che ti permette anche di cancellarli, modificarli e di trasformare i post in bozze e viceversa. Blogspot inoltre ti assicura una rapida diffusione blog.
Attraverso un semplice click sul tasto blog successivo il sito vi  reindirizzerà a un blog con poche visualizzazioni inserendolo velocemente negli indici di Google.

La nostra recensione, secondo me è il mio team, blogspot è uno dei migliori programmi per la creazione di blog efficienti e ottimali. Il fatto che blogspot ti dia la possibilità di andare a modificare direttamente la HTML del blog mi dà un grande senso possesso e di serenità.  Secondo me blogspot è proprio un programma da utilizzare almeno una volta.

Programma java LJFS

Main
*************************************************************

    public static void main(String[] args){
        AlgoritmiCode FJFS=new AlgoritmiCode();
        FJFS.InizializzaArray();
        FJFS.ElencaValoriProcessi();
        FJFS.LavoroComplessivoDaSvolgere();
    }
}

*************************************************************

public class AlgoritmiCode {
        public int processi[] = new int[10];
      
      
    public void InizializzaArray() {
        for (int i = 0; i < processi.length; i++) {
            processi[i] = (int) (Math.random() * 10);
        }
    }

    public void ElencaValoriProcessi() {
        for (int i = 0; i < processi.length; i++) {
            System.out.print(processi[i] + " ");
        }
    }

    public int LavoroComplessivoDaSvolgere() {
        int ris=0;
        for (int i = 0; i < processi.length; i++) {
            ris = ris + processi[i];
        }
        System.out.println(ris);
        ris=ris/processi.length;
        System.out.println(ris);
      
        return ris;
    }
}

I SUCCHIACERVELLI

 Ecco una lista di alcuni parassiti crea-zombie.

 CIRRIPDE PARASSITA (ospite del granchio ragno): un maschi di granchio ragno parassitato da un cirripede subisce una femminilizzazione: non sviluppa più chele per il combattimento e il suo addome si espande, fornendo un utero che il parassita riempie con una sacca contenente la sua nidiata. Accudite dal granchio le uova si schiudono e migliaia di piccoli cirripedi danno inizio ad una nuova infestazione.
GORDIO(ospite del grillo domestico): le larve del parassita infestano il grillo mentre si ciba di insetti morti, poi crescono al suo interno. Poichè il grillo è un'insetto terrestre , ma lo stadio adulto del ciclo vitale del verme è acquatico, quando il verme maturo è pronto per emergere modifica il cervello del grillo, inducendolo ad abbandonare la terraferma e a compiere un salto suicida nel più vicino specchio d'acqua. Mentre il grillo annega il verme adulto (lungo più di 30 cm) esce dal suo corpo.
VESPA PARASSITA  (ospite della coccinella): La vespa femmina punge la coccinella, depositando un uovo nel suo corpo. Dopo la schiusa dell'uovo, la larva comincia a cibarsi degli organi interni del suo ospite. Quando è pronto, il parassita emerge e tesse un bozzolo tra le zampe della coccinella. La coccinella si è liberata del torturatore ma rimane in stato di schiavitù, proteggendo il bozzolo dai predatori.
VERME ACANTOCEFALO ENDOPARASSITA (ospite del crostaceo anfipode): Quando la larva del parassita matura il crostaceo nuota dal fondo degli stagni in cui vive verso la superficie. Qui trova anatre e altri uccelli acquatici, bramosi di cibarsi di lui. Per il parassita (divenuto arancione grazie ai pigmenti assorbiti dalla vittima) tutto cio fa parte del piano, poichè completa la sua trasformazione solo nell'intestino degli uccelli acquatici.
PLATELMITA PARASSITA (ospite della rana toro): Dopo essersi riprodotte all'interno di una chiocciola, le larve del parassita trovano un girino di rana toro e si fanno strada negli abbozzi dei suoi arti posteriori. Durante la crescita il girino sviluppa delle deformazioni (arti mancanti, sovrannumerati o malformati). Le rane adulte deformi non sono in grado di fuggire e vengono mangiate dagli uccelli acquatici  che diffondono il parasita in altri stagni.
FUNGO DEL GENERE Ophiocordyceps (ospite della formica amazzonica): Quando le spore del fungo si depositano sulla formica, penetrano attraverso il suo esoscheletro e si insediano nel cervello, costringendo l'ospite ad abbandonare il suo habitat e ad arrampicarsi su un'albero. Con il corpo invaso dal fungo e pronto ad esplodere, la formica morente si ancora ad una foglia. Gambi di fungo spuntano dall'esoscheletro della formica e fanno piovere le loro spore sulle formiche sottostanti ricominciando il ciclo.

fonte: National Geographic Italia

Linux Mint

Linux Mint è una distribuzione GNU/Linux per personal computer, conosciuta per la sua facilità d'uso e per la semplicità di installazione. Si basa su Ubuntu (a sua volta basata su Debian) e usa sia repository propri sia quelli di Ubuntu.

Il nostro team ha usato questa distribuzione per più di due anni e ci ha soddisfatto molto. La sua interfaccia grafica è molto simile a Windows, Infatti presenta un desktop e un "Menù" molto simile allo Start di Windows. Tutta l'interfaccia è sviluppata dagli sviluppatori sia dal team di Linux Mint sia la sua enorme e attivissima community.La sua caratteristica principale è di essere molto facile da utilizzare, come ho detto prima, infatti (anche se l'intero file .iso pesa solo 1,3 GB) Linux Mint ha un enorme varietà di programmi preinstallati. Dalle utility di manipolazione immagini come GIMP ai milioni di tool per il Terminal come DD o Netstat per non citare i pacchetti Libreoffice.
Linux Mint è disponibile con interfaccia utente Cinnamon, Mate, KDE o Xfce.
Io utilizzo come sistema operativo principale la versione MATE la quale è molto stabile.

Recensione Xubuntu

Xubuntu é un sistema operativo Linux gratuito open source. Questo sistema é una versione ubuntu, altro sistema Linux, ma con la grafica XFCE ed inoltre occupa solo 256 mb di RAM, a differenza di ubuntu che occupa 512 MB.
Xubuntu ha una grande compatibilità con Windows. Una peculiarità di tutti i linux é la quasi totale assenza di virus, esistono molte versioni di linux ed é sconveniente creare un virus per una sola variante, ma é anche molto difficile.
Xubuntu é un ottimo sistema operativo per svariate ragioni tra cui troviamo la fantastica grafica, la semplicità di funzionamento, la stabilità e inoltre ci sono oltre 40000 programmi gratuiti installabili con semplice click (ci sono oltre 250 programmi nella categoria Scienze e ingegneria).
Per i più nostalgici esistono programmi per modificare la grafica in modo da renderlo simile al sistema operativo abbandonato come ad esmpio Windows XP.

Xubuntu non ha solo pregi infatti é sconsigliato abbandonare Windows se si usa il computer solo per giocare o se si usa un software proprietario insostituibile o se hai un nuovo hardware non supportato.

Per me Xubuntu é un ottimo sistema operativo e se si possiede un computer vecchio che non riuscite a farlo funzionare bene allora dovreste installarlo.

(clicca su un'immagine per aprire il sito di xubuntu)

 

Programma per calcolare le distanze tra due punti cartesiani (metodo ad oggetti)

 Classe xy

public class xy {
    int x1=(int) (Math.random()*10);
    int y1=(int) (Math.random()*10);
    int x2=(int) (Math.random()*10);
    int y2=(int) (Math.random()*10);
    double a;double b;double c;double xf;double yf;
   
    public double distoriginex1(){
        a=(double) Math.hypot(x1, y1);
        return a;
    }
    public double distoriginex2(){
        b=(double) Math.hypot(x2, y2);
        return b;
    }
    public double distpunti(){
        xf=x1-x2;
        yf=y1-y2;
        c=(double) Math.hypot(xf, yf);
        return c;
       
    }
    public void stampa(){
        System.out.println("x1 "+x1);
        System.out.println("y1 "+y1);
        System.out.println("x2 "+x2);
        System.out.println("y2 "+y2);
        System.out.println("distanza di x1,y1 da 0,0="+a);
        System.out.println("distanza di x2,y2 da 0,0="+b);
        System.out.println("distanza di x1,y1 da x2,y2="+c);
    }

MAIN 

    public static void main(String[] args) {
        xy cartesio= new xy();
        cartesio.distoriginex1();
        cartesio.distoriginex2();
        cartesio.distpunti();
        cartesio.stampa();
       
    }
}

Disegnare e fare muovere uno sprite in Java

Ho implementato un programma scritto in Java che disegna su una finestra (JFrame) uno sprite (che troverete nel file .zip) il quale puo essere mosso con quattro tasti (JButton) Troverete qui il link al file sorgente che potete scaricare e modificare a vostro piacimento. NOTA BENE: Il programma è stato compilato con le librerie Java v8 perciò possono esserci problemi di compatibilità con altre versioni.

Download http://goo.gl/dgFDDg

Un labirinto difficilissimo

 

Per gli amanti dei labirinti complicati ho creato un labirinto difficile :)

Paradigma obgect oriented esempio

package primooggetto;
/**
 *
 * @author 3c Marco
 */
public class Gatto {
     String s_nome;
     String s_età;
     String s_razza;
     String s_colore;
    
     int i_salute;
     int i_x;
     int i_y;
     boolean b_sverminato;
     boolean b_orfano;
     boolean b_genere;
     /**
      * @return void
      * il metodo costruttore gatto
      * inizializza un gatto in posizione
      * 0 0 ( origine grafica)
      * il gatto è in buona salute =100
      */
     public void Gatto()
     {   i_x=0;
         i_y=0;
         s_nome="";
         i_salute=100;
         b_orfano=false;
         b_sverminato=false;
        
      }
   /**
    *
    * @return true se ha mangiato nelle ultime
    * 8h
    */
    public boolean mangiare()
    {
        if (i_salute<100)
            i_salute=i_salute+5;
     
       return true;
    }
    
    
}








in questo programma si può vedere in pratica la teoria esplicata nei post precedenti.

Android-x86

Android-x86 è un progetto non ufficiale che ha come obiettivo la realizzazione di un porting del sistema operativo mobile Android che sia capace di essere eseguito su piattaforme x86 e quindi di essere utilizzato sulla maggior parte dei PC compresi le applicazioni di virtualizzazione.

L'ultima versione stabile è la 4.4-r1 del branch che Google ha soprannominato "KitKat". Questa versione è la prima a implementare drivers OpenGL 2.0 e perciò consente di giocare a giochi che necessitano grafica 3D usando interamente tutte le capabilità del nostro chip grafico. Gli sviluppatori però non hanno incluso nel kernel il supporto per i chip PowerVR.

Il progetto è interamente open-source e porta tutta la tecnologia di casa Google su praticamente ogni computer che monta una CPU Intel o AMD. Il nostro team lo ha testato sia usando una flash usb sia all' interno di Virtualbox, funzionando quasi del tutto tranne per un crash della applicazione Gallery riscontrato su Virtualbox.

Sito ufficiale: http://www.android-x86.org/

 

 

PARADIGMA AD OGGETTI

La programmazione tradizionale si è sempre basata sull’utilizzo di strutture dati e su funzioni e procedure. Questo metodo di sviluppo del software viene detto funzionale, con esso si organizza un intero programma in moduli che raccolgono gruppi di funzioni. Ogni funzione accede ad uno o più gruppi di dati. I metodi di sviluppo funzionale hanno pero’ notevoli debolezze:

• A causa deglistretti legami tra le funzioni e i dati, si arriva ad un punto in cui ogni modifica software provoca degli effetti collaterali su altri moduli con enormi difficolta di debug della applicazione.
  

• Difficolta’ di riutilizzo del software. Ogni volta che si vuole riciclare una funzione bisogna apportare delle modifiche strutturali per adeguarla alla nuova applicazione.
  

La programmazione orientata agli oggetti è un modo alternativo di scomposizione di un progetto software: in essa l’unità elementare di scomposizione non è più l’operazione ma l'oggetto, inteso come modello di un’entità reale.
Questo approccio porta ad un modo nuovo di concepire un programma: il software è ora costituito da un insieme di entità interagenti, ciascuna provvista di una struttura dati e dell’insieme di operazioni che l’oggetto è in grado di effettuare su quella struttura. Poiché ciascun oggetto incapsula i propri dati e ne difende l’accesso diretto da parte del mondo esterno, si è certi che cambiamenti del mondo esterno non influenzeranno l’oggetto o il suo comportamento.
D’altra parte per utilizzare un oggetto basta conoscere che dati esso immagazzina e che operazioni esso fornisce per operare su questi dati, senza curarsi dell’effettiva realizzazione interna dell’oggetto stesso. Questo nuovo modo di sviluppare programmi software è più vicino alla nostra realtà quotidiana. Pensiamo ad un oggetto del mondo reale, ad esempio una automobile.
Una automobile ha un insieme di caratteristiche, Inoltre essa dispone di operazioni da svolgere esclusivamente con essa, ad esempio:

• accensione.
• cambio della marcia.
• parcheggio.
  

è giusto correllare le sue caratteristiche e le suo operazioni in una sola entita’ (un solo oggetto). Inoltre la programmazione ad oggetti favorisce la programmazione di gruppo, poiché gli oggetti non possono dipendere dall’implementazione di altri oggetti, ma solo dalle loro operazioni, perciò un programmatore può sviluppare un oggetto senza preoccuparsi della struttura degli altri elementi che compongono il sistema.
La parte del programma che fa uso di un oggetto si chiama client. Un linguaggio di programmazione è definito ad oggetti quando permette di implementare tre meccanismi usando la sintassi nativa del linguaggio:

• incapsulamento
  
• ereditarietà
  
• polimorfismo
  

L'incapsulamento consiste nella separazione della cosiddetta interfaccia di una classe dalla corrispondente implementazione, in modo che i client di un oggetto di quella classe possano utilizzare la prima, ma non la seconda. L'ereditarietà permette essenzialmente di definire delle classi a partire da altre già definite. Il polimorfismo permette di scrivere un client che può servirsi di oggetti di classi diverse, ma dotati di una stessa interfaccia comune; a tempo di esecuzione, quel client attiverà comportamenti diversi senza conoscere a priori il tipo specifico dell'oggetto che gli viene passato.

STORIA

Il primo linguaggio di programmazione orientato agli oggetti fu il Simula (1967), seguito negli anni settanta da Smalltalk e da varie estensioni del Lisp. Negli anni ottanta sono state create estensioni orientate ad oggetti del linguaggio C, e di altri linguaggi. Negli anni novanta è diventato il paradigma dominante, per cui gran parte dei linguaggi di programmazione erano o nativamente orientati agli oggetti o avevano una estensione in tal senso. Linguaggi che supportano solo il paradigma di programmazione orientata agli oggetti sono Smalltalk ed Eiffel. Più spesso si incontra una realizzazione non esclusiva del paradigma di programmazione orientata agli oggetti, come in C++, Java, Delphi, Python, C#, Visual Basic .NET, Perl, PHP.

CLASSI E OGGETTI

Le classi definiscono dei tipi di dato e permettono la creazione degli oggetti secondo le caratteristiche definite nella classe stessa. Grazie alle relazioni di ereditarietà, è possibile creare nuove classi a partire da quelle esistenti, estendendole con caratteristiche aggiuntive. La classe è composta da:

• attributi (analoghi ai membri di un record) cioè delle variabili e/o costanti che definiscono le caratteristiche o proprietà degli oggetti instanziabili invocando la classe; i valori inizializzati degli attributi sono ottenuti attraverso il cosiddetto costruttore;
  
• metodi (procedure che operano sugli attributi);
  

È preferibile considerare la classe come un modello astratto istanziabile. In altri termini una classe è paragonabile al progetto di un'infrastruttura che può poi essere messa in opera/esercizio ovvero realizzata o meno con l'istanziazione dei suoi oggetti tutti con medesime caratteristiche, ovvero gli attributi, su cui opereranno i metodi o funzioni.
Un oggetto è una istanza di una classe. Esso è dotato di tutti gli attributi e i metodi definiti dalla classe, ed agisce come un fornitore di "messaggi" che il codice eseguibile del programma può attivare su richiesta. Inviare un messaggio ad un oggetto si dice, in gergo, invocare un metodo su quell'oggetto. Il metodo riceve come parametro l'oggetto su cui è stato invocato, che può essere referenziato tramite una parola-chiave o una sintassi apposita, anche se è passato come parametro implicito; per esempio, in C++, in Java, e in C# si usa la parola-chiave this , mentre in Smalltalk, in Objective-C, Python e in Ruby si usa la parola-chiave self. Dal punto di vista del calcolatore, ogni oggetto è identificato da una certa zona di memoria, nella quale sono memorizzati gli attributi, e il valore di questi ultimi determina lo stato interno dell'oggetto. Istanziare un oggetto vuol dire allocare memoria ed eventualmente inizializzarla secondo le specifiche definite dalla classe. Molti linguaggi forniscono un supporto per l'inizializzazione automatica di un oggetto, con uno o più metodi speciali, detti costruttori. Analogamente, la fine della vita di un oggetto può essere gestita con un metodo detto distruttore.

Libro sull'energia

Didapages è un programma che permette di realizzare libri multimudiali, dove si possono inserire testi, immagini, video e anche esercizi per la comprensione. La nostra classe ha realizzato un libro che riassume in modo semplice e chiaro l’evoluzione delle scoperte fatte dall’uomo, dalla Preistoria fino ai giorni d’oggi. Alla fine di ogni capitolo ci sono delle mini verifiche che il lettore potrà eseguire per poter verificare cosa ha appreso di tutto il capitolo appena letto. Le soluzioni ai quesiti compariranno ogni volta che darete la risposta.

Tutti coloro che invece vorranno sperimentare il programma Didapages potranno scaricarlo gratuitamente da Internet. 

Stringhe java in informatica

Una stringa in informatica è una sequenza di caratteri. Sequenze di altri tipi di dato vengono chiamati vettori o, in inglese, array.
Può essere composta da byte nel caso delle stringhe con codifica ascii o da word per le codifiche Unicode e UTF.
Spesso la sequenza di dati di cui è composta una stringa viene conclusa con un carattere speciale denominato NULL (come nel linguaggio C) che serve ad indicare la fine della stringa, anche se esistono diversi metodi di rappresentazione, alcuni dei quali utilizzano un diverso terminatore oppure si appoggiano ad altri sistemi per la determinazione della lunghezza (ad esempio un dato contenente la lunghezza della stringa immagazzinato a parte).
In molti linguaggi di programmazione, come ad esempio Java oppure C# la stringa, per motivi di sicurezza, è un oggetto non modificabile (in Java è addirittura non estendibile). Questo vuol dire che ogni qualvolta viene assegnato un nuovo valore ad una stringa (operazione di concatenazione, rimozione o aggiunta caratteri) in realtà vengono create nuove stringhe.

3000!!!!

la soglia delle 3000 visualizzazioni in 7 mesi è sorprendente  !!
continuate  a visualizzare questo blog  quando arriveremo a 3200 vi faremo avere novita sul mondiale di calcio  in brasile ;comunque ci scusiamo per la piccola pausa che abbiamo preso nei  mesi precedenti..




                                 fatto da Milani Samuele,Paleino Simone, Mao Leonardo

Esercizio java metodi statici

public static void main(String[] args) {
int m = 10000, d = 0, n = 0;
int v[]=new int [10000];
primi(v, m, d, n);
        }
public static int primi (int m,int d,int n,int v[]){
            System.out.println("Numeri primi");
        for (n=2; n            d = 2;
            while ((n%d != 0) && (d < n))
                d++;
            if (d==n)
                System.out.println(n);
            for (int i=0;i                v[i]=n;
            }
        }
        return 0;
    }

    private static void primi(int[] v, int m, int d, int n) {
        throw new UnsupportedOperationException("Not yet implemented");
    }
}

Matrici

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package javaapplication1;

/**
 *
 * @author USER
 */
public class JavaApplication1 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        int v[][]=new int [50][50];
        for (int m = 0; m<50 data-blogger-escaped-br="" data-blogger-escaped-m="">        {
           
            for (int n=0; n<50 data-blogger-escaped-br="" data-blogger-escaped-n="">                    {
                        v[m][n]= (int) (Math.random()*2);
                        System.out.println(v[m][n]);
                    }
        }
       
    }
}
   

Informatica

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package javaapplication1;

/**
 *
 * @author MAJORANA
 */
public class JavaApplication1 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        int a[]=new int [2];
        int b[]=new int [2];
        int c[]=new int [2];
        for (int i=0; i        {
            a[i]=(int) (Math.random()*10);
            b[i]=(int) (Math.random()*10);
            c[i]=(int) (Math.random()*10);
            System.out.println(a[i]+" "+b[i]+" "+c[i]);
        }
        int d,dx,dy;
        d=(a[0]*b[1])-(a[1]+b[0]);
        System.out.println("Ds="+ d);
        dx=(c[1]*b[0])-(c[0]+b[1]);
        System.out.println("Dx="+ dx);
        dy=(a[0]*c[1])-(a[1]+c[0]);
        System.out.println("Dy="+ dy);
        if (d!=0)
        {
              System.out.println("determinata");
        }else{
            if ((d==0) && (dx!=0) || (dy!=0))
        {
             System.out.println("impossibile");
        }else{
                if ((d==dx)&&(dy==0)&&(dx==dy))
                {
                      System.out.println("indeterminata");
                }
            }
           
            }
    }
}

Ho scoperto da poco un’interessante funzione alla già utilissima applicazione di Google Calendar che vorrei condividere con i miei affezionati lettori ;). Con molti dei miei alunni utilizziamo da tempo l’applicazione Calendar; di solito ne incorporiamo una nel sito di classe così che ci possa fare da diario comune.
La utilizziamo in modo ordinario e, delle molteplici funzionalità, sfruttiamo le semplici caratteristiche di promemoria con annotazioni essenziali per i compiti o di altre attività degne di nota. Come dicevo ho scoperto da poco che nella sezione “labs”, voce che appare nel menù impostazioni (quello con l’ingranaggio!! ), si può abilitare i propri calendari ad una funzionalità molto interessante: quella di allegare dei documenti agli eventi.
In altre parole oltre all’annotazione, al giorno e all’ora dell’evento si può aggiungere un documento che accompagnerà i promemoria.
Dopo aver salvato le impostazioni nell’area “modifica evento”, insieme alle tante opzioni sotto la descrizione, apparirà una voce “allegato”; una volta cliccata potrete, così come una banale applicazione di posta, allegare un file.
Non ci sono limiti particolari ma occorre tener presente che tutti i file allegati dovranno essere condivisi pubblicamente poiché a coloro che vedranno il calendario non è concessa automaticamente l'autorizzazione a visualizzare i documenti.
Dopo aver allegato  il file occorre quindi passare da Drive per modificare le dovute opzioni di condivisione, se naturalmente non si è già allegato un file pubblico
Insomma un’interessante funzione che non può certo sostiture le applicazioni specifiche di scambio e condivisione ma che aggiunge senza dubbio potenzialità informative alla già ottima Calendar.
Fate però attenzione perché tutte le nuove funzioni inserite in labs non sono definitive e spesso, proprio per il loro carattere sperimentale, spariscono senza preavviso.

FatboyJim per Android

Jim è il tuo eroe! Può correre, fare le scorreggine e i ruttini. Tutto questo perchè deve affrontare il compito più arduo dei giorni nostri: deve scegliere di nutrirsi con il cibo salutare o il cibo spazzatura.
Tu cosa mangi tutti i giorni? Inizi a preferire il cibo spazzatura o il cibo salutare di una buona dieta mediterranea?
Comprendi dal tutorial come fare per correre più a lungo per sopravvivere mangiando cibo buono ed evitando il cibo transgenico. Scegli di far rimanere in forma Jim altrimenti potrebbe ingrassare a dismisura.
Prova a fare il tuo record della corsa mantenendo in forma Jim.
Il junk food ti fa ingrassare a dismisura se continui così muorirai giovane ma ricordati che puoi scegliere il cibo buono con lo sfondo verde per tenerti in forma. Attento al tuo peso. Attento alle tue scelte.
I punti gnam dipendono da quanto cibo salutare riesci a mangiare. Solo il cibo salutare ti da abbastanza anticorpi per affrontare errori come ingurgitare cibo mutante o cibo spazzatura. Senza aver mangiato abbastanza cibo salutare
la tua aspettativa di vita scende. Impara a mangiare cibo buono.Impara a valutare il tuo peso corporeo.
Buon divertimento dal team di wikipin.it

Recupero informatica 28/01

 recupero informatica 28/01
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package javaapplication3;

import javax.swing.JOptionPane;

/**
 *
 * @author Administrator
 */
public class JavaApplication3 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO ricerca di un numero dentro un vettore inizializzato casualmente
        int v[]=new int [100];
        for(int i=0; i<v.length; i++)
        {
        v[i]=(int) (Math.random()* 100);
        System.out.print(v[i]+ " " );
        }
        String tmp;
        tmp=JOptionPane.showInputDialog("Che elemento vuoi ricercare");
        int n = Integer.valueOf(tmp);
       
      for (int c=0;c<v.length;c++)
      {
          if (n==v[c])
          {
              System.out.println(" ");
          System.out.println(v[c]+" numero desiderato con indice"+c);
      }
      else
              {System.out.println("elemento non trovato");
     }
     
      }
    }
  
}

 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package javaapplication1;

/**
 *
 * @author MAJORANA
 */
public class JavaApplication1 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        int elemento_da_ricordare, risultato;
        int v[]={1,12,16,17,55,76,24,98,75,43,21};
        elemento_da_ricordare=17;
        risultato=RicercaElementoVettore(v,elemento_da_ricordare);
        System.out.println(risultato);
    }
      public static int RicercaElementoVettore(int v[], int elemento)
        {int indiceElemento=1;
       
        int i; int n = v.length;
        for(i=0;i<n;i++)
        {if (v[i]==elemento)
        {indiceElemento=i;
               
                }
           
        }  
        return indiceElemento;

recupero informatica

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package javaapplication3;

import javax.swing.JOptionPane;

/**
 *
 * @author Administrator
 */
public class JavaApplication3 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO ricerca di un numero dentro un vettore inizializzato casualmente
        int v[]=new int [100];
        for(int i=0; i<v.length; i++)
        {
        v[i]=(int) (Math.random()* 100);
        System.out.print(v[i]+ " " );
        }
        String tmp;
        tmp=JOptionPane.showInputDialog("Che elemento vuoi ricercare");
        int n = Integer.valueOf(tmp);
      
      for (int c=0;c<v.length;c++)
      {
          if (n==v[c])
          {
              System.out.println(" ");
          System.out.println(v[c]+" numero desiderato con indice"+c);
      }
      else
              {System.out.println("elemento non trovato");
     }
    
      }
    }
 
}

spiegazione 14/1/14

package javaapplication1;
public class JavaApplication1 {
public static int SommaElementiVettore(int v[])
{int risultato=0;


return risultato;
}

//metodo che somma gli elementi maggiori di una certo valore.
public static int SommaVettoreConMargine(int v[],int valore)
{int risultato=0;


return risultato;

}
public static void Inizializzazione(int g[])
{
for(int i=0;i<g.length;i++)
{
g[i]=(int)(Math.random()*100);
}

}
public static void StampoVettore(int f[])
{
for(int i=0;i<f.length;i++)
{
System.out.println(f[i]+" ");
}
}
public static void main(String[] args) {
int m[]= new int[100];
Inizializzazione(m);
int sommatoria;
sommatoria=SommaElementiVettore(m);
StampoVettore(m);
int sommatoriaSpeciale;
sommatoriaSpeciale=SommaVettoreConMargine(m,10);

lo potete trovare su wikipin  al  numero304 ,con i nomi SAMUSIMO.

es info

package ricerca.elemento;
/**
 *
 * @author INFO 4
 */
public class RicercaElemento {
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        int elemento_da_ricercare,risultato;
int vet[]={4,45,97,4,3,21,0,9,15,28,36,11};
elemento_da_ricercare=45;
risultato= RicercaElementoVettore(vet,elemento_da_ricercare );
System.out.println("Elemento si trova con indice = "+ risultato);
int produttoria1=Produttoria(vet);
System.out.println("la produttoria degli elementi del vettore è "+produttoria1);
int sommatoria=Sommatoria(vet);
System.out.println("la sommatoria degli elementi del vettore è "+sommatoria);
}

public static int RicercaElementoVettore(int v[],int elemento)
{ int indiceElemento=-1;
int sommaelementi=0;
int i; int n=v.length;
for(i=0;i<n;i++) {
  
sommaelementi=sommaelementi+v[i];
if (v[i]==elemento)
{ indiceElemento= i; }
}
return indiceElemento;
    }
public static int Sommatoria(int v[])
{ int sommatoria=0;
    for(int i=0;i<v.length;i++)
    { sommatoria=sommatoria+v[i];
    }
        return sommatoria ;
}

public static int Produttoria(int v[])
{ int produttoria=1;
    for(int i=0;i<v.length;i++)
    { produttoria=produttoria*v[i];
    }
        return produttoria ;
}
}

fatboyjim gioco android

sulla playstore  di un telefono android è appena uscito un gioco  dal titolo fatboyjim è molto istruttivo e originale provatelo, purtroppo non ce ancora la versione per apple.

wikipin

esercizio di oggi lo potete trovare su wikipin numero 308

5 catastrofi causate dal nucleare

La catastrofe al Fukushima, lo scorso marzo, ha riportato l’attenzione dell’opinione pubblica sul tema del nucleare, al punto da indurre diversi governi europei a rivedere i propri programmi in merito. Anche il governo italiano non ha potuto ignorare le perplessità diffusesi riguardo alla sicurezza delle centrali nucleari e il prossimo 12 giugno il Paese sarà chiamato ad esprimere la propria volontà attraverso il referendum.
Quando si pensa ai rischi relativi all’energia nucleare la mente corre presto all’aprile del 1986 e allo scenario apocalittico di Černobyl’, di fatto l’incidente più grave mai avvenuto. Ma ciò che probabilmente la maggior parte della gente ignora è che i casi sono stati e sono più numerosi di quanto la stampa non renda noto.
Proprio in occasione del referendum del 12-13 giugno Frontiere News vuole ricordare le 5 catastrofi nucleari più gravi della storia. Per stabilire quali fossero si è scelto di riferirsi alla scala INES (International Nuclear and radiological Event Scale), la scala internazionale degli eventi nucleari e radiologici, sviluppata a partire dal 1989 dall’Agenzia Internazionale per l’Energia Atomica (AIEA) per classificare gli incidenti nucleari e radiologici. Questa scala, costituita da sette gradi, è logaritmica, perciò il passaggio da un livello all’altro indica un aumento del danno pari a dieci volte.
1957, Disastro di Kyshtym (URSS). Conosciuto anche come “incidente di Majak”, è stato classificato al 6° livello della scala INES, inferiore solo ai casi di Černobyl’ e Fukushima. L’impianto nucleare di Majak, all’epoca dei fatti, costituiva un sito militare dell’Unione Sovietica e ospitava un impianto per la produzione di materiale nucleare, nella fattispecie plutonio, destinato alla fabbricazione di bombe atomiche. Il 29 settembre 1957 un guasto al sistema di raffreddamento di una delle cisterne provocò un’esplosione chimica della potenza di 70-100 tonnellate di dinamite, in seguito alla quale si riversarono nell’atmosfera radionuclidi per un rilascio di radioattività pari a 74 PBq. Venne contaminata un’area di 23.000 km², comprendente le province di Chelyabinsk, Sverdlovsk e Tyumen, e circa 10 mila persone furono evacuate e trasferite altrove. Attualmente il governo non ritiene la zona pericolosa per gli esseri umani e tuttavia persistono tracce di radioattività elevata nelle zone colpite più pesantemente.
1979, incidente di Three Mile Island (USA). Con il suo indice INES 5 rappresenta il più grave incidente nucleare avvenuto negli Stati Uniti, sebbene non abbia provocato morti accertate. Erano le 4:00 del 28 marzo 1979 quando un guasto al circuito di refrigerazione secondario causò un blocco della portata di alimentazione ai generatori di vapore. L’insufficienza della strumentazione nella sala di controllo e l’inadeguata preparazione del personale impedì di diagnosticare il problema, con conseguente degenerazione della situazione. La refrigerazione forzata del reattore fu ristabilita alle 19:50 dello stesso giorno, mentre la refrigerazione per convezione naturale venne ripristinata solo un mese dopo, il 27 aprile. Durante l’incidente il nocciolo radioattivo subì una pericolosa fusione parziale e l’unità riportò danni tali da comportarne la chiusura.
1986, disastro di Černobyl’ (URSS). Come anticipato, al caso di Černobyl’ è stato attribuito il livello più alto della scala INES. Il 26 aprile 1986, durante un test definito “di sicurezza” il nocciolo del reattore 4 della centrale ucraina al confine con la Bielorussia fu spinto a un brusco e incontrollato aumento della potenza che comportò la scissione dell’acqua di refrigerazione in ossigeno e idrogeno a pressioni altissime. Le tubazioni del sistema di raffreddamento del reattore si ruppero e il contatto dell’idrogeno e della grafite incandescente delle barre di controllo con l’aria innescò un’esplosione potentissima che scoperchiò il reattore, incendiandolo. Dal reattore si propagò una nube di materiali radioattivi che contaminò ampie aree intorno alla centrale e che raggiunse anche l’Europa e in parte la costa orientale dell’America Settentrionale. Circa 336 mila persone vennero evacuate. Secondo il controverso rapporto ufficiale redatto dalle agenzie dell’ONU i morti accertati sono 65, mentre 4 mila sono quelli indirettamente associabili al disastro nell’arco di 80 anni. Dati contestati da Greenpeace che, invece, ha ipotizzato 6 milioni di decessi, a livello mondiale, in 70 anni.
1999, disastro di Tokaimura (Giappone). L’incidente, di livello INES 4, al sito della JCO, una piccola fabbrica di combustibile nucleare, fu considerato all’epoca il terzo più grave incidente della storia del nucleare civile, preceduto solo da Three Mile Island e Černobyl’. Violando le norme ministeriali, furono miscelati con acido nitrico 16 kg di uranio esaurito anziché 3 kg. Immediata la reazione nucleare a catena e la fortissima emissione di raggi gamma. Lo stabilimento venne evacuato e due operatori morirono per le radiazioni subite, mentre altre 119 persone furono contaminate in misura minore.
2011, disastro di Fukushima Dai-ichi (Giappone). Ultima, solo in ordine cronologico, la catastrofe di Fukushima, provocata dal terremoto del Tōhoku dello scorso marzo e non ancora arginata. In un primo momento l’incidente era stato classificato al livello 4 della scala INES, poi al 5 e infine, considerando l’insieme dell’evento, al grado 7. Gli impianti coinvolti sono quelli di Fukushima Dai-ichi, Fukushima Dai-ni, Onagawa, Tokai e il Centro di riprocessamento di Rokkasho, ma a destare maggiore preoccupazione è il primo, in particolare il reattore 4. L’edificio di quest’ultimo, infatti, è quello maggiormente danneggiato dalle esplosioni di idrogeno e qui sono a rischio fusione non le barre di combustibile all’interno del Vessel, bensì quelle stoccate nelle vasche del combustibile esausto, dunque collocate al di fuori della struttura di contenimento primaria del reattore. La concomitanza dei danni comportati dal sisma e dallo tsunami e dell’incidente nucleare rende ancora difficile determinare l’entità della catastrofe e le conseguenze che essa avrà, non solo in Giappone, ma anche a livello planetario.

Valentina Severin

javapplication metrici 5

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package javaapplication1;

/**
 *
 * @author MAJORANA
 */
public class JavaApplication1 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        int elemento_da_ricordare, risultato;
        int v[]={1,12,16,17,55,76,24,98,75,43,21};
        elemento_da_ricordare=17;
        risultato=RicercaElementoVettore(v,elemento_da_ricordare);
        System.out.println(risultato);
    }
      public static int RicercaElementoVettore(int v[], int elemento)
        {int indiceElemento=1;
       
        int i; int n = v.length;
        for(i=0;i        {if (v[i]==elemento)
        {indiceElemento=i;
               
                }
           
        }  
        return indiceElemento;
    }
}

juve roma 2013 -2014

 ieri si è conclusa la partita tra juve roma finita 3 a0 per i bianconeri.
gol di vidal 18°
          bonucci48°
             vucinic su rigore
ora la juve si porta a +8 dalla roma  seguono napoli inter e fiorentina

Honda è il nuovo giocatore del milan.

blog 2013-2014

ora con l'anno nuovo continueremo a postare immagini divertenti, classifiche musicali, sportive, aggiornamenti   e tantissime altre cose continuate a seguirci......
BUON ANNO A TUTTI!!!!!

capodanno 2014