Thread: Rejecting certain inputs

I don't know any way to stop a user from entering whatever he wants. The program can refuse to accept what is entered and ask the user to enter what the program wants. This can be done repeatedly until the user enters what is desired or quits trying.

What does the code you posted do when the user enters something other than a number?

If you were using a GUI instead of the command prompt, there would be a handful of ways to do this.

As for preventing the program from crashing, use and if statement and the Scanner's hasNextInt() method to check if the input was an int before calling the nextInt() method.

Put the code that causes the exception inside a try{}catch block. The catch block code will get control if an exception is thrown.

You could do what Norm said, but a potentiality "better" solution (because it does not require the creation of exceptions) would be to do something like this:

if(sc.hasNextInt()) {
     int subjectNum = sc.nextInt();
     ... // Continue with program or whatever
}
else {
     ... // Do something if the input isn't an int
}

Put the code in a while() loop that continues looping UNTIL the user enters the desired input.

getting a stack overflow error o.O

That is probably because of the recursive call:

   studentNumberEntered(number, sc);

Use a loop instead of a recursive call.

You are getting a stack overflow because of infinite recursion (a method calling itself forever with no exit-case). This would be occurring if your catch block is always being hit. My guess would be that it is constantly reevaluating the input, and constantly failing.

I am actually a little surprised you can even run that code. It shouldn't compile, since it doesn't appear you ever return a value from the method.

The code still has the recursive call. That should be removed and a loop used instead.

A potential change to your current code (so numberEntered stays within the scope of the method):

public static int studentNumberEntered(Scanner sc) {
	int numberEntered = 0;
	try { 	
		System.out.print("Student Number: ");
		numberEntered = Integer.parseInt(sc.nextLine());	
		numberEntered = numberCheck(numberEntered, sc);
	}	
	catch (Exception E) {
		System.out.println("------------");
		System.out.println("   ERROR    ");
		System.out.println("------------");
		System.out.println("");
		numberEntered = studentNumberEntered(sc);
	}
	return numberEntered;
}

This is assuming you want the recursive call. A loop could just as easily be used, as Norm suggested.

apply the same concepts to a array, with 2 outputs?

Sorry I don't understand your question.
An array can hold many values.

What do you want the method to do?

If an array is defined inside of a method, it can be passed as an arg to another method that is called from that method:

void aMethod() {
  int[] anArray = {1};      // define an array in this method
  int valReturned = methodToCall(anArray); //  pass local array to another method
}
int methodToCall(int[] array) {  // receive an array
   return 0;    //  return an int
}

what are the benfits of a loop from a recursive call?

For your purposes, yes, because a loop is more simple and easier to understand (as well as a handful of other reasons around complexity).
In my experience, recursion is most powerful when you are attempting to implement a brute-force algorithm where you want to be able to "undo" calculations if the chosen path fails to reach the end-goal. It isn't "undo" in the sense that you are probably thinking. Rather, recursion "remembers" the place of all previous recursion iterations. So if you were designing a game or something where a computer-controlled bot solves a maze, the brute-force approach of doing that would be to use recursion, because it allows the bot to back-track if it reaches a dead-end.

Beware of using recursion if you are attempting to modify primitives in an array. Changes you make to primitives in later recursion iterations will not change the values in the array in previous recursions. This is true for primitives because of something called mutability.