[Shinji]

La programmazione si compone di tre categorie fondamentali:
- programmazione funzionale (es. Scheme, Lisp)
- programmazione imperativa (es. C/C++, Java, Pascal, etc..)
- programmazione logica (es. ProLog)

Scheme è un linguaggio funzionale (a differenza di Pascal, C/C++, Java che sono imperativi)... tuttavia è grazie alla funzionalità di Scheme che mi è stato più facile imparare il Java... anche se come sintassi sono completamente diversi... ti faccio vedere solo due esempi semplici semplici:

TEMA: Creare un programma, in linguaggi Scheme e Java, che, dati un indice naturale n, calcoli l'n-esimo numero di Fibonacci.

i numeri di fibonacci sono definiti come fib(n-2) + fib(n-1); esempi:
fib(0) = 0 //convenzione
fib(1) = 1 //convenzione
fib(2) = fib(0) + fib(1) = 0 + 1 = 1
fib(3) = fib(1) + fib(2) = 1 + 1 = 2
fib(4) = fib(2) + fib(3) = 1 + 2 = 3
fib(5) = fib(3) + fib(4) = 2 + 3 = 5
fib(6) = fib(4) + fib(5) = 3 + 5 = 8
...
più in generale: fib(n) = fib(n-2) + fib(n-1)

soluzione del problema
Soluzione SCHEME

(define (fibn n)
  (if (< n 0)
      (error "ERRORE! Inserire un valore intero positivo.")
      (fibn-alg n '(1 0) 0 1)))
(define (fibn-alg n fib fib1 fib2)
    (let ((fibn (+ fib1 fib2)))
      (cond ((= n 0) 0)
            ((= n 1) (car fib))
            (else (fibn-alg (- n 1) (cons fibn fib) fib2 fibn)))))

Soluzione JAVA (usando gli array (impropriamente chiamati "vettori"))

 public class Fibn {
    public static void main (String[] args) {
        if (args.length<1)
            System.out.println("ERRORE! Inserire un indice naturale.");
        else {
            int[] fibarray = new int[3];
            int fib1=0, fib2=1, fibn;
            int n = Integer.parseInt(args[0]);
            if (n >= 1) {
                for (int i=2; i<(n+1); i++) {
                    fibarray[2] = fibn = fib1 + fib2;
                    fibarray[0] = fib1 = fib2;
                    fibarray[1] = fib2 = fibn;
                }
            }
        System.out.println(indice (fibarray));
        }
    }
    public static int indice(int[] fibarray) {
        int j = 2;
        return fibarray[j];
    }
}

Soluzione JAVA (usando il ritorno intero)
questo te l'ho anche commentato (se ti può servire per capire meglio)

public class Fibn {
// Main class
    public static void main(String[] args) {
    // controllo sul valore n passato in input
        if (args.length<1)
            System.out.println("ERRORE! Inserire almeno un valore intero positivo.");
        else {
        // se esiste un n in input, viene prelevato ed assegnato alla variabile n
            int n=Integer.parseInt(args[0]);
            if (n < 0) {
                System.out.println("ERRORE! Il valore deve essere intero positivo.");
            } else {
            // si passa il valore n alla funzione ausiliaria che itera il risultato
                System.out.println(algorithm(n));
            }
        }
    }
// Algoritmo (funzione ausiliaria) per il calcolo dell'ultimo numero della serie
    public static long algorithm(int n) {
    // dichiarazione e inizializzazione delle variabili
        long fib;
        long fib1=0, fib2=1, fibn;
        // algoritmo in un ciclo for con dichiarazione del contatore i
        if (n >= 1) {
            for (int i=2; i<(n+1); i++) {
                fibn = fib1 + fib2; // calcola l'n-esimo numero della serie
                fib1 = fib2; // assegna a fib1 il penultimo numero della serie
                fib2 = fibn; // assegna a fib2 l'ultimo numero della serie
            }
            return fib2; // restituisce l'n-esimo numero della serie
        } else {
            fib = 0;
            return fib;
        }
    }
}

se hai dubbi o incertezze chiedi pure (magari via pm... che se no qua ci prendono per pazzi... lol)