This is my code, and it works exactly how I want it to, but I picked up using
String n = null;
when dealing with switch statements, can someone explain to me why it works the way it does in this code so that I can better understand this concept?
//Tells a user what number corresponds with what numbers on a telephone
import java.util.Scanner;
public class KeyPad
{
public static void main (String [] args)
{
//Initialize Scanner
Scanner input = new Scanner(System.in);
//Variables
String x;
char c;
//Input
System.out.println("Enter a letter: ");
x = input.next();
//Convert to lowercase
x = x.toLowerCase();
c = x.charAt(0);
//Assign reference variable
String n = null;
//Switch conditions
switch (c)
{
case 'a':
case 'b':
case 'c': n = "2";
break;
case 'd':
case 'e':
case 'f': n = "3";
break;
case 'g':
case 'h':
case 'i': n = "4";
break;
case 'j':
case 'k':
case 'l': n = "5";
break;
case 'm':
case 'n':
case 'o': n = "6";
break;
case 'p':
case 'q':
case 'r':
case 's': n = "7";
break;
case 't':
case 'u':
case 'v': n = "8";
break;
case 'w':
case 'x':
case 'y':
case 'z': n = "9";
break;
}
//Output
System.out.println("The corresponding number is " + n);
}
}
This is a question of scope. The Java language considers the entire body of a switch statement as a single scope--it does not try to do in-depth analysis of code paths. For example, the following could spell trouble:
switch(foo){
case 1:
int i = 1;
// note no break
case 2:
int i = 4;
}
This would effectively be a double-declaration. Or, the following could be problematic, and the compiler doesn't analyze it, thus assuming that it would be problematic:
switch(foo){
case 1:
int i = 1;
// note no break
case 2:
i = 4;
}
To handle this, the entire switch block is treated as a single scope. You must declare the variable once in this scope, and you must ensure that all code paths will actually give the variable a value, by immediately initializing it to null. The null value simply indicates the lack of an object, as opposed to String s; which might never get initialized by some otherwise-valid code path.
Well, in order to understand that you have to look after the bytecode of such a class.
In order to clarify I've created a test class as follow:
switch(c){
case 1:
String temp = "first";
System.out.println(temp);
break;
case 2:
temp = "second";
System.out.println(temp);
break;
case 3:
String temp2 = "third";
System.out.println(temp2);
}
Using the javap to generate the bytecode, we get the following LocalVariableTable:
LocalVariableTable:
Start Length Slot Name Signature
0 65 0 args [Ljava/lang/String;
2 63 1 c I
31 10 2 temp Ljava/lang/String;
44 10 2 temp Ljava/lang/String;
57 7 3 temp2 Ljava/lang/String;
What that table of local variables tell us is:
There is a variable of type String named temp which has a valid context from instruction 31 to 41 (31 + 10)
There is a another variable of type String named temp which has a valid context from instruction 44 to 54 (44 + 10)
There is another variable of type String named temp2 which has a valid context from 57 to 64 (57 + 7)
So, the compiler does not treated the whole switch block as one scope, it did created two distinct scopes for the "String temp" variable.
If you try another example, as the source code bellow:
//first scope
{
String myLocal = "first";
System.out.println(myLocal);
}
//second scope
{
String myLocal = "second";
System.out.println(myLocal);
}
The respective bytecode points to the following LocalVariableTable:
LocalVariableTable:
Start Length Slot Name Signature
67 7 2 myLocal Ljava/lang/String;
77 7 2 myLocal Ljava/lang/String;
What shows that two scopes was created for variable myLocal of type String. Exactly the same way it created for the switch statement.
In your case the switch statement just use a LocalVariableTable which has a scope that covers the whole switch statement, that is the main reason you can set a String declared outside the switch. The code bellow illustrate that:
int c = 5;
String temp = null;
switch(c){
case 1:
temp = "first";
System.out.println(temp);
break;
case 2:
temp = "second";
System.out.println(temp);
break;
}
Now, notice the bytecode generate:
LocalVariableTable:
Start Length Slot Name Signature
0 89 0 args [Ljava/lang/String;
2 87 1 c I
4 85 2 temp Ljava/lang/String;
Here you can see the "String temp" variable has a scope of length 85, what covers the whole switch statement, what allows you to reference the variable inside it.
Sorry for the long answer, but such a question is like ask a mathematician to explain what a function means. In order to answer you question is necessary to understand deep concept of how source code works behind the scenes.
Hope this can help, regards.
If I understand the question correctly you are either asking "Why do I set the string n equal to null?" or "Why does my switch statement work correctly?" So I will answer both.
First, You are setting the string to null first to ensure that it is blank, and contains no data( or to a memory location of "0" ). Basically, you are telling the compiler that n is actually nothing at all, it doesn't even exist, except for in its name.
Now, on to the switch statement. You have your standard fall through switch statement. So if the variable c in your snippet is one of the letters "a" "b" or "c" it will then set the string n ( which until this point is still nothing, if you attempt to use it it will throw an error ) and sets it to the string "2"(I assume you know the difference between strings and integers ).
You may be thinking, why does n still exist after the switch statement( or why is it still not null )? This is because of the scope of the variable. Since it was declared inside of main, anything inside of main will be able to see, and change the value of n. now if you did the following
.
.
.
string n = null;
switch(c)
{
case "a":
case "b":
case "c":
string n="2";
break
.
.
.
}
System.out.println("The corresponding number is " + n);
You would get an error, since you re-declared n, in the scope of the switch statement. In this example the n in the switch statement DOES NOT have the same scope as the n being printed. Where as in your example the "case "c": n=2;" n DOES have the same scope( and in fact the same variable ) as the n being printed to the screen.
Also, just a quick fyi, You could also use this method as a check to see that n was in fact set to something before printing it ( and prevent troublesome ArgumentNull exceptions ).
if(n!=null)
System.out.println("The corresponding number is " + n);
else
System.out.println("The character you entered does not have a corresponding number");
I hope this helps clear things up a bit!
Related
My question is simple, will the following code work, if it can't is there a way to accomplish the same effect
int day = 5;
String dayString;
switch (if (day > 0) {
case 1:
dayString = "Monday";
day++;
break;
case 2:
dayString = "Tuesday";
day++;
break;
case 3:
dayString = "Wednesday";
day++;
break;
case 4:
dayString = "Thursday";
day++;
break;
case 5:
dayString = "Friday";
day++;
break;
case 6:
dayString = "Saturday";
day++;
break;
case 7:
dayString = "Sunday";
day++;
break;
default:
dayString = "Invalid day";
day++;
break;
}
System.out.println(dayString);
The output should be friday, basically my question is can you put if statements or while or for or do or other statements within the parameters of the respective statements.
Java's syntax has a number of different structures. Of particular relevance here are expressions and statements.
An expression is something that has a value. A statement is an instruction to do something (*).
if is a statement. Its general syntax is:
if (expression) statement
(The {} is a kind of statement too, which is why you can use braces to surround the code you want to execute).
expression has to be of type boolean or Boolean.
switch is also a statement. Its general syntax is:
switch (expression) {
// ...
}
The expression has to be of type int, char, short, byte (or their boxed counterparts), String or enum. You can't use boolean, long, float or double.
Because the switch needs an expression in the parentheses, you can't use a statement there.
(*) Some expressions can "do something" too, that is, they have a side effect, for example i++. These are special expressions in the Java language called StatementExpressions, which can be written as a statement by adding a semicolon: i++; is legal because it meaningfully does something, i; is not.
the above code will not work...there is syntax error in that code.you cannot add an if condition inside the braces of switch ...it expects a variable to evaluate ...the conditions are given using the case statements...to get friday as output simple put the variable 'day' inside the switch braces--like this-> switch(day)
I'm using switch case in Java for the first time and I'm a bit unsure about the syntax. Assuming the setTeamName function works, which it does, would the following function make all of the teams in my array have the placeholder String as it's name or should I from case 0: since i starts at 0?
public static Team[] makeTeams(){
Team[] teams = new Team[10];
for(int i = 0; i < teams.length; i++){
switch(i){
case 1: teams[0].setTeamName("Arsenal");
case 2: teams[1].setTeamName("Arsenal");
case 3: teams[2].setTeamName("Arsenal");
case 4: teams[3].setTeamName("Arsenal");
case 5: teams[4].setTeamName("Arsenal");
case 6: teams[5].setTeamName("Arsenal");
case 7: teams[6].setTeamName("Arsenal");
case 8: teams[7].setTeamName("Arsenal");
case 9: teams[8].setTeamName("Arsenal");
case 10: teams[9].setTeamName("Arsenal");
}
}
return teams;
}
use break Statement after every instruction in case.
Your case statements would need to start from 0, because as you rightly observe, i starts at zero. However, this appears to be the least of your problems (unless this is just an exercise in using switch case).
You don't need switch case in this situation at all. Plus, you never create any objects in the array, so every time you attempt to access the array at a particular index, you're going to get a null reference exception. The following will suffice:
Team[] teams = new Team[10];
for (int i = 0; i < teams.length; i++) {
teams[i] = new Team();
teams[i].setTeamName("Arsenal");
}
What you've effectively got in your original example is an example of an anti-pattern, the Loop-switch sequence. If you want the original example to work properly using this anti-pattern (for educational purposes only), you need to add break; statements to ensure that your case statements don't fall through:
Team[] teams = new Team[10];
for (int i = 0; i < teams.length; i++) {
teams[i] = new Team();
switch (i) {
case 0: teams[0].setTeamName("Arsenal"); break;
case 1: teams[1].setTeamName("Arsenal"); break;
case 2: teams[2].setTeamName("Arsenal"); break;
case 3: teams[3].setTeamName("Arsenal"); break;
case 4: teams[4].setTeamName("Arsenal"); break;
case 5: teams[5].setTeamName("Arsenal"); break;
case 6: teams[6].setTeamName("Arsenal"); break;
case 7: teams[7].setTeamName("Arsenal"); break;
case 8: teams[8].setTeamName("Arsenal"); break;
case 9: teams[9].setTeamName("Arsenal"); break;
}
}
Without the breaks, every case statement under the one that matches i is evaluated, e.g. when i == 0, all of the case statements will be executed.
You do have options in filling up the array but if your task requires you to use only switch then start with case 0 instead of 1, since 0 is the "first" case you are encountering.
Do you really need switch here? for loop will be enough.
Switch just move execution to case row and ignore another case for next time. So when you give i = 1 to switch all of the case statement will be executed. You can prevent it by using break;
switch (i) {
case 1:
teams[0].setTeamName("Arsenal");
break;
case 2:
teams[1].setTeamName("Arsenal");
break;
}
You are doing a lot of unnecessary work. Try
public static Team[] makeTeams(){
Team[] teams = new Team[10];
for(int i = 0; i < teams.length; i++){
teams[i] = new Team();
teams[i].setTeamName("Arsenal");
}
return teams;
}
You have few errors in your code:
1) You do not have case 0 - so it is not used. Suggestion is always use default case.
2) Each case should be finished with break; Otherwise all cases below are executed too. For example for case 9 these cases are called 9 and 10. and for case 1 all 10 cases have been called. (but for case 0 in your code none is called).
3) You had reserved array of 10 teams but you did not populated objects to this array. You code will produce null pointer exception.
Going through some switch command tutorials from various sources. I am trying to create a small program based on this SwitchDemo tutorial ( I have removed some repeated code to save space):
public class SwitchDemo {
public static void main(String[] args) {
int month = 8;
String monthString;
switch (month) {
case 1: monthString = "January";
break;
case 2: monthString = "February";
break;
case 3: monthString = "March";
break;
default: monthString = "Invalid month";
break;
}
System.out.println(monthString);
}
}
In this code monthString does not need to be initialized in the line String monthString;. However I want to add user input to the code using Scanner as follows:
import java.util.Scanner;
public class App2 {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int month = scan.nextInt();
String monthString;
switch (month) {
case 1:
monthString = "January";
break;
case 2:
monthString = "February";
break;
case 3:
monthString = "March";
break;
default:
System.out.println("Invalid month");
break;
}
System.out.println(monthString);
}
}
In this case the code does not work and Eclipse tells me I need to initialize monthString; eclipse corrects it by adding = null to String monthString.
What is the reason for this?
P.s I am completely new to Java, so could you explain it like you would to someone who does not know any programming?
Thanks
It's because monthString is a local variable and there's a path you can take where it's not initialized and you're still trying to use it.
That's just not allowed in Java. I think the reason is it's an easy way for Java to prevent you from making a mistake. It forces you to acknowledge that you haven't set monthString to anything yet but you're still trying to use it. 9 times out of 10, that's an mistake on the developers part, so Java won't let you do it.
One way to fix it is to set monthString to something in your default:. You can also initialize it to null, as #Eran said.
You can either initialize it to null when declaring it :
String monthString = null;
or give it some default value in the default clause of the switch.
default:
System.out.println("Invalid month");
monthString = null; // or some other default value
break;
}
If you don't do one of the two, you might reach System.out.println(monthString); before the String is ever initialized, which is an error.
Basically, any time you can get to a statement, any variable used in that statement has to have been initialized.
In your second example, the default case breaks out of the switch statement, but the code then executes the next statement after the switch: System.out.println(monthString). So, the variable has to have been initialized in all code paths that lead there, but it wasn't in the default case.
The reason for this is that it's part of the Java language specification. You are not allowed to access the value of a local variable (or blank final field) if the variable has not been "definitely assigned". The compiler performs an analysis to ensure assignment occurs before an access, no matter what code path is taken to the access.
In the case of your second example, the path through the default switch case never assigns a value to monthString, and then the value of the variable is accessed in the println statement.
The full definite assignment rules are pretty complex. You can read them in chapter 16 of the spec here.
Alternatively you could try something like this:
String monthString;
switch (month) {
case 1:
monthString = "January";
break;
case 2:
monthString = "February";
break;
case 3:
monthString = "March";
break;
default:
monthString = "Invalid month";
break;
}
System.out.println(monthString);
In order to use a local variable in java it must be initialized to something even if that something is setting it equal to null.
What eclipse is doing is following all of the different paths between creating monthString and where it is used in System.out.println(monthString) and determining that there is no place where the monthString is initialized.
If you were to declare monthString within the enclosing SwitchDemo class then your code would also be valid because there is no way for eclipse to determine if another method has set monthString. (You would of course have to declare monthString as static if you were to do this because you can only access static variables from within a static method).
In Java, can I fall through only one of the cases in a switch statement? I understand that if I break, I will fall through to the end of the switch statement.
Here's what I mean. Given the following code, on case 2, I want to execute case 2 and case 1. On case 3, I want to execute case 3 and case 1, but not case 2.
switch(option) {
case 3: // code
// skip the next case, not break
case 2: // code
case 1: // code
}
No, what you are after is not possible with a switch statement. You will fall through each case until you hit a break. Perhaps you want case 1 to be outside of your switch statement, so that it is executed regardless.
Put the code into methods and call as appropriate. Following your example:
void case1() {
// Whatever case 1 does
}
void case2() {
// Whatever case 2 does
}
void case3() {
// Whatever case 3 does
}
switch(option) {
case 3:
case3();
case1();
break;
case 2:
case2();
case1();
break;
case 1:
case1(); // You didn't specify what to do for case 1, so I assume you want case1()
break;
default:
// Always a good idea to have a default, just in case demons are summoned
}
Of course case3(), case2()... are very poor method names, you should rename to something more meaningful about what the method actually does.
My suggestion is to not use fallthrough for anything except cases like the following:
switch (option) {
case 3:
doSomething();
break;
case 2:
case 1:
doSomeOtherThing();
break;
case 0:
// do nothing
break;
}
That is, giving several cases the exact same block of code to handle them (by "stacking" the case labels), making it more or less obvious what the flow is here. I doubt most programmers intuitively check for case fall through (because the indentation makes a case look like as a proper block) or can efficiently read code that relies on it - I know I don't.
switch(option)
{
case 3:
...
break;
case 2:
...
break;
}
... // code for case 1
You can custom the condition if you want to split cases
const { type, data } = valueNotifications
let convertType = ''
if (data?.type === 'LIVESTREAM' && type === 'NORMAL') {
convertType = 'LIVESTREAM1'
} else convertType = type
switch (convertType)
My use case has split the type from value notifications, but I have a specific LiveStream case which only shows in data.type is 'LIVESTREAM'
Something like this maybe.
switch(option) {
case 3: // code
// skip the next case, not break
// BLOCK-3
case 2: // code
if(option == 3) break;
// BLOCK-2
case 1: // code
// BLOCK-1
}
In switch statement if you don't break the subsequent case is executed. To give you simple example
int value = 2;
switch(value) {
case 1:
System.out.println("one");
break;
case 2:
System.out.println("two");
case 3:
System.out.println("three");
break;
}
Will output
two
three
Because break wansn't executed on case 2
I have been working on a program to count vowels in inputted text. It uses this method to recursively add to a vowel count every time a vowel is found. However, I get an out of bounds error every time lastPos reaches negative 1. How can I get this to stop once lastPos reaches -1?
static int R_countVowels(String s, int lastPos)
{
switch (s.charAt(lastPos))
{ case 'a': case 'A':
case 'e': case 'E':
case 'i': case 'I':
case 'o': case 'O':
case 'u': case 'U': return (1 + R_countVowels(s, --lastPos));
default: return R_countVowels(s, --lastPos);
}
}
I'm assuming this is homework so no code.
Recursive functions require a base case. You need to define your base case to return 0 (no vowels) for an empty input and check for the base case before your inductive step (recursive call).
Insert an if before the switch():
if (lastpos < 0) {
// stop the recursion
}