[JAVA]: Passaggio di parametri a metodi e generazione di eccezioni

[E_T]

buongiorno, a breve avrò l'esame di java, potreste spiegarmi come si fa il passaggio di parametri e come si lanciano le eccezioni che non riesco proprio a capirtli?
grazie a tutti

[LeleFT]

Che cosa, in particolare, non riesci a capire?
Le due cose sono decisamente scollegate tra loro.


Ciao.

[E_T]

si si lo so che sono scollegate ma se in un esercizio dopo aver creato una classe e un costruttore mi chiede di fare il passaggio dei parametri che devo fare? e se in un'altro mi chiede di lanciare un eccezione in modo tale che si ottenga un messaggio di errore?
grazie

[andbin]

Originariamente inviato da E_T
se in un esercizio dopo aver creato una classe e un costruttore mi chiede di fare il passaggio dei parametri che devo fare? e se in un'altro mi chiede di lanciare un eccezione in modo tale che si ottenga un messaggio di errore?

Scusa ... quale è il problema preciso con il passaggio dei parametri??? Intanto credo che tu sappia che in Java i parametri sono passati sempre e solo per valore.
Per "lanciare" eccezioni si usa la parola chiave throw.

[LeleFT]

Originariamente inviato da E_T
si si lo so che sono scollegate ma se in un esercizio dopo aver creato una classe e un costruttore mi chiede di fare il passaggio dei parametri che devo fare?

Come che devi fare? Se hai una classe il cui costruttore richiede dei parametri, glieli passi.
Esempio:

public class MiaClasse {
   public MiaClasse(int parametro) {
      System.out.println("mi hai passato il parametro: " + parametro);
   }
}

public class AvviaProgramma {
   public static void main(String [] args) {
      MiaClasse mc = new MiaClasse(1);   // Qui faccio il passaggio di parametri: 1 è il parametro
   }
}

Non credo che ci siano delle difficoltà in questo... :master:

e se in un'altro mi chiede di lanciare un eccezione in modo tale che si ottenga un messaggio di errore?
grazie

Qui hai due modi: o lanci l'eccezione esplicitamente attraverso l'istruzione throw, oppure provochi un'eccezione e la fai lanciare al tuo metodo tramite la sola clausola di intestazione throws.
Ecco i due esempi in sequenza:

public void mioMetodo throws MiaEccezione {
   throw new MiaEccezione("Eventuale messaggio");
}

..

public void mioMetodo throws Exception {
   int a = 10 / 0;
}

Ciao.

[maurizio2]

I tipi fondamentali(int, double, long etc...) sono passati per valore:

   public static void main(String[] args) {
       int f = 2;
       trasform(f);
       System.out.println(f);//visualizza 2, nessuna modifica nell'ambiente chiamante
    }
    
    public static void trasform(int i){
        i = 3;
    }

Invece le classi sono anche loro passate per valore, ma il riferimento che
punta all'oggetto, quindi:

public class Main {   
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        int f = 2;
        MyClass myClass = new MyClass(f);
        transformClass(myClass, 4);
        System.out.println(myClass);//visualizza 4
    }
    
    
    
    public static void transformClass(MyClass myClass, int newValue){
        myClass.setInt(newValue);
        
    }
    
    public static class MyClass{
        int i;
        MyClass(int i){
            this.i = i;
        }
        
        public void setInt(int newValue){
            this.i = newValue;
        }
        
        public int getInt(){
            return i;
        }
        
        public String toString() {
            return String.valueOf(i);
        }
        
        
    }
    
}

Come puoi vedere nell'ambiente di trasformClass() modifichi l'oggetto
che si trova in main(), ma in realta' l'oggetto e' unico nella memoria
e quindi le modifiche si riflettono ovunque.
Conclusione: gli oggetti vengono passati per valore ma solo il riferimento
senza clonare l'intero oggetto.
Ciao