Numeri primi, tentativo di applicazione

Sto costruendo, come esercizio, un'applicazione che trovi i numeri primi esistenti fino ad un limite passato come argomento.
Ho elaborato il ciclo che dovrebbe occuparsene, se qualcuno vuole dargli un'occhiata sono interessato alle vostre critiche.
La cosa che mi fa strano, in questa fase è che, nonostante le variabili siano dichiarate come "int", il passaggio di valori anche piuttosto grandi, ho provato a impostare "Lim" a 500.000, non turba il compilatore che esegue senza fare una piega. Qualcuno a dirmi perché?
Allego il codice con il metodo.
Il passaggio successivo sarà l'implementazione di una maschera a cui passare i valori e per la visualizzazione dei primi 5.000 risultati. L'intenzione successiva è quella di creare un file .txt in cui salvare le ricerche più consistenti con un'adeguata formattazione, magari facilitando l'analisi dei risultati con un foglio di calcolo.

package numeriprimi;

/*@author luca*/
class NumeriPrimi 
{
public static int Lim = 1;


public static void main(String[] args)
{
NumeriPrimi(3,3);
}        
private static long NumeriPrimi(int NNP, int Lim)
{
/*private long Serie[];//accumula la serie fino a Lim
private long NP;//contegio dei nueri primi trovati
private long NN;//sucessione dei numeri naturali*/
boolean VP = false;
int t;
int Rest;
int NP;
int NN;
NumeriPrimi.Lim = 500;
int[] Serie;
Serie = new int[NumeriPrimi.Lim];

//Serie[0]=1;

 if (Lim < 3)//se il imite entro cui cercare è minore di tre si valutano 
            //i tre casi possibili
{
    switch (Lim)
    {
        case 0:
            NNP = 0;
            NP = 0;
            break;
        case 1:
            NNP = 1;
            NP =  1;
            Serie[0] = 1;
            break;
        case 2:
            NNP = 2;
            NP = 2;
            Serie[0] = 1;
            Serie[1] = 2;
            break;
        default:
            break;
    }    
}

else
    {
    //si impostano manualmente i valori fino a 3 per evitare complicazioni
    NNP = 3;
    NP = 3;
    NN = 3;
    t = 1;
    Rest = 1;
    Serie[0] = 1;
    //System.out.println("Valore di Serie[0]: " + Serie[0] + ".");
    Serie[1] = 2;
    //System.out.println("Valore di Serie[1]: " + Serie[1] + ".");
    Serie[2] = 3;
    //System.out.println("Valore di Serie[2]: " + Serie[2] + ".");
    //inizio del ciclo
    {
    while(t < NumeriPrimi.Lim)
        {
        //System.out.print("Primo while, ripetizione N° " + t + "\n");
        NN = NN + 1;
        Rest = 1;

        while((Rest < NumeriPrimi.Lim/2) && (NN < NumeriPrimi.Lim))
            S2:{
                //System.out.print("#########Secondo while, valore della variabile Rest: " 
                  //               + Rest + " valore della variabile NN: " 
                    //            + NN + "\n");//espressione di controllo per debug
                if ((Serie[Rest]) != 0)
                {
                //System.out.print("Primo if, valore del numero in array: " + Serie[Rest] + "\n");//espressione di controllo per debug
                /*L'inserimento della clausola di controllo in questa posizione,
                su una serie di 5.000 numeri, porta il tempo di esecuzione, lasciando
                attive le espressioni di controllo, da 3' e 57'' a 2' e 27''.
                L'eliminazione delle espressioni di controllo comunque, abbatte
                il tempo a 1'' per l'esecuzione completa*/
                
                if (Serie[Rest] > NN/2)//controlliamo l'espressione del modulo per tentare di arrestala al raggiungimento di NN/2
                {
                //System.out.print("break if, uscita dal ciclo, raggiunta" 
                //+ " la metà dei valori presenti nell'array.\n"
                //+ "Valore dell'elemento attuale: " + Serie[Rest]
                //+ " Valore di NN: " + NN + "\n");//espressione di controllo per debug
                //System.out.print("******Raggiunta  la metà dei valori, NUMERO PRIMO: " 
                  //              + NN + "\n");//espressione di controllo per debug
                //System.out.print("Trovato numero primo: " + NN +", elemento N°" + NNP + ".\n\n\n");
                Serie[NNP] = NN;
                NN = NN + 1;
                t = t + 1;
                NNP = NNP + 1;
                Rest = 1;
                break S2;
                }    
                    if ((NN % Serie[Rest])!= 0)
                        {
                        //System.out.print("Secondo if, resto della divisione fra: "
                          //              + NN + " e " + Serie[Rest] + ": " + 
                            //            NN % Serie[Rest] + " POSSIBILE NUMERO PRIMO.\n");//espressione di controllo per debug
                        Rest = Rest + 1;//se NN è divisibile per un numero che lo precede allora non è primo e si va oltre
                        }
                    else
                        {
                        //System.out.print("Else del secondo if, numero non primo: "
                  //                      + NN +  "\n\n");//espressione di controllo per debug    
                        NN = NN + 1;
                        Rest = 1;
                        }
                }
                else    
                {
                //System.out.print("ELSE DEL PRIMO IF, NUMERO PRIMO: " + NN + "\n");//espressione di controllo per debug
                //System.out.print("Trovato numero primo: " + NN +", elemento N°" + NNP + ".\n\n\n");
                Serie[Rest] = NN;
                NN = NN + 1;
                t = t + 1;
                NNP = NNP + 1;
                Rest = 1;
                }
                }
        t = t + 1;
        }
        System.out.print("Trovati : " + NNP + " numeri primi tra 0 e " + NumeriPrimi.Lim + ".\n");
        //NNP = NN -1;
        //NP = NP +1;
        //Rest = Rest + 1;
        //t = 1;
        //Serie[Rest] = NNP;
        }
    }
 //for di controllo per debug
for(int i = 0; i < Serie.length; i++)
    if(Serie[i] != 0)
        System.out.println(Serie[i]);

System.out.print("Fine della serie.");
return NNP;
}
}