I have a problem using switch statement when I tried to deal with a special situation. For example, I have 3 cases: A, B, C.
for A, I want to do statement_1 and statement_3.
for B, I want to do statement_2 and statement_3.
for C, I want to do nothing
if I use if-else statement, it will look like this:
if ( not Car){
do statement_3
if Bag
do statement 2
else if Apple
do statement 1
}
when i try to do it from switch statement im getting trouble
switch (variable){
case A: do statement_1
case B: do statement_2
// how to do statement 3 here?
}
The default section handles all values that are not explicitly handled by one of the case statements.
switch(var){
case A:
//do stuff
break;
case B:
//do stuff
break;
default:
//do stuff
break;
}
EDIT: I have just read the question again and I think I understood you, if you want to "do statement_1 and statement_3 for A and statement_2 and statement_3 for B" you just have to write it:
switch(var){
case A:
statement_1
statement_3
break;
case B:
statement_2
statement_3
break;
}
I guess you forgot to add a break statement. For example if expression == A and you don't have break all statements will be executed, whereas if you add break, it will not execute the rest of the cases. Also, the default is the one which is executed if expression doesn't satisfy any of the cases.
switch(expression){
case A:
statement_1
statement_3
break;
case B:
statement_1
statement_2
break;
default:
break;
}
For each case, you have to write all the required "statements" and then add break; otherwise the next case will be also executed:
switch (variable) {
case A:
statement_1;
statement_3;
break;
case B:
statement_2;
statement_3;
break;
case C:
default:
break;
}
Here default case and C case are the same and do nothing.
Related
I have this code with the switch statement which I got from this post, and it works absolutely fine:
String getOrdinal(final int day) {
if (day >= 11 && day <= 13) {
return "th";
}
switch (day % 10) {
case 1: return "st";
case 2: return "nd";
case 3: return "rd";
default: return "th";
}
}
But if I change it to something like the following, it breaks, as all the cases besides case 1 gets executed:
static String getOrdinal(final int day) {
StringBuilder ordinalBuilder = new StringBuilder();
ordinalBuilder.append("<sup>");
if (day >= 11 && day <= 13) {
ordinalBuilder.append("th") ;
}
switch (day % 10) {
case 1: ordinalBuilder.append("st");
case 2: ordinalBuilder.append("nd");
case 3: ordinalBuilder.append("rd");
default: ordinalBuilder.append("th");
}
ordinalBuilder.append("</sup>");
return ordinalBuilder.toString();
}
This prints 2<sup>ndrdth</sup> when I pass in 2. I tried changing the builder to buffer but I got the same response... Could this be a bug or am I making some mistake?
It's a bug in your code. You forgot to put in a break after each case:
switch (day % 10) {
case 1: ordinalBuilder.append("st"); break;
case 2: ordinalBuilder.append("nd"); break;
case 3: ordinalBuilder.append("rd"); break;
default: ordinalBuilder.append("th"); break;
}
I don't see any bug here, at least not in the way the language is working. The behavior of a switch statement, by design, is that it will start executing statements at the case label which matches the argument, and then continue until the end of the block. So
switch (x) {
case 1:
// do thing 1
case 2:
// do thing 2
case 3:
// do thing 3
default:
// do nothing
}
will do both things 2 and 3 if x is 2, and will do things 1, 2, and 3 if x is 1.
To get the behavior you're probably looking for, end each case with a break:
switch (x) {
case 1:
// do thing 1
break;
case 2:
// do thing 2
break;
case 3:
// do thing 3
break;
default:
// do nothing
break;
}
(strictly speaking the break at the very end is unnecessary, but I often put it in out of habit).
The reason you didn't have this problem in the first code example is that return is like a super-break: it has the same effect as break, namely ending execution within the switch block, but it also ends execution of the whole method.
you need to add a 'break' statement in every switch case.
It was worked previously because you made a return from method...
A "break;" statement separates the cases from one another so in order to execute the statements in a specific case just break the case as soon as it comes to an end.
If you don't use break the compiler thinks that it can continue execution of all the cases up to the end of the program.
The first version returns before continuing on in the case statement. The second version needs a break; statement to get the same behavior.
Luckily with the introduction of switch statements on Java 12 which also introduced
"arrow case" labels that eliminate the need for break statements to
prevent fall through (source).
Therefore the modern version of your code looks like the following:
String getOrdinal(final int day) {
if (day >= 11 && day <= 13) {
return "th";
}
return switch (day % 10) {
case 1 -> "st";
case 2 -> "nd";
case 3 -> "rd";
default -> "th";
};
}
I see this question is over 8 years old, but this answer should help anyone landing on this page.
Firstly lets's understand how switch cases work. In C, C++, Java, JavaScript, and PHP while executing switch statements all the cases following the satisfactory case are executed, unlike in Go where only selected case is executed.
For example:
public class Main
{
public static void main(String[] args) {
int day = 11;
switch (day % 10) {
case 1: System.out.println("st");
case 2: System.out.println("nd");
case 3: System.out.println("rd");
default: System.out.println("th");
}
}
}
Currently, day value is set to 11 and hence very first case satisfy the condition, and hence all below cases would be executed. The output should look like the one below:
st
nd
rd
th
Now let's change day value to 13 resulting in the third case to satisfy the condition and hence below output is obtained:
rd
th
Hence if you want to break the code after first satisfactory case is found then put break; condition in the end. In the code mentioned in the question return; does the job of breaking the code.
Also, most of the novice java programmers believe that SWITCH statements are syntactical sugar to IF statements wherein programmers don't have to repetitively mention conditions. But that's not the case as IF's are meant to exit after the execution of satisfactory condition while SWITCH still continues execution.
Switch cases can be utilized to achieve the purpose like one mentioned in below example:
wherein
for Grade A "Excellent!" should be printed
for Grade B and C "Well done" should be printed
for Grade D "You passed \n Try hard next time" should be printed
for Grade F "Try hard next time" should be printed
and if not a valid case i.e grade is found than "Invalid Grade" should be printed.
public class Test {
public static void main(String args[]) {
// char grade = args[0].charAt(0);
char grade = 'C';
switch(grade) {
case 'A' :
System.out.println("Excellent!");
break;
case 'B' :
case 'C' :
System.out.println("Well done");
break;
case 'D' :
System.out.println("You passed");
case 'F' :
System.out.println("Try hard next time");
break;
default :
System.out.println("Invalid grade");
}
System.out.println("Your grade is " + grade);
}
}
Add a break statement at the end of the every line in each case or just use the return statement.
Suppose i have a piece of code that should be performed in each of the cases of a switch case construct:
switch(myEnum){
case A:
System.out.println("hi from" + myEnum.getName());
break;
case B:
System.out.println("hi from" + myEnum.getName());
break;
...
}
Is there a way to avoid writing the line
System.out.println("hi from" + myEnum.getName());
in each of the cases and defining a method called by each of the cases?
If you have two cases which result int he same action, you could do something like so:
switch(myEnum){
case A:
case B:
System.out.println("hi from" + myEnum.getName());
break;
...
}
The test action for the test case A should trickle down to be handled by B.
If you want
System.out.println("hi from" + myEnum.getName());
to execute in any case, you don't need to put it in switch case.
Also, if you place the statement in case B, and you don't put break statement in case A, then you will execute in both case A and case B
You can fallthrough - Can I use OR statements in Java switches?
case A:
case B:
System.out.println("hi from" + myEnum.getName());
I am expecting my input to be one of three groups of chars and need to decide what to do with it based on which group it falls in. I'm trying to figure out how to define a switch with multiple cases to do this. Here is what I have so far:
while(in.hasNextChar())
{
char test = in.nextChar();
List<Signal> out = new List<Signal>(0);
switch(test)
{
case '1','0','x','X':
out.add(fromString(test));
break;
case ' ','/t':
break;
default:
throw new ExceptionLogicMalformedSignal;
}
}
return out;
}
You have the syntax wrong. You need to take advantage of fall-through:
switch(test) {
case '1':
case '0':
case 'x':
case 'X':
out.add(fromString(test));
break;
case ' ':
case '\t':
break;
default:
throw new ExceptionLogicMalformedSignal;
}
A case is just a label, very similar to what you'd use with a goto (which is essentially what is happening behind the scenes). It's not a statement, since it does nothing itself — it just names an address. So if test is '0', it can happily continue through the 'x' and 'X' cases to reach the actual statement code since there's not anything being done by those labels. Only break "ends" a case.
You can actually insert code between cases even without a break:
switch(test) {
case '1':
System.out.println("This is printed by case '1'");
case '0':
System.out.println("This is printed by both case '1' and case '0'");
break;
case 'x':
case 'X':
System.out.println("This is only printed by the Xs");
break;
default:
break;
}
I was answering a Java test and come across the question:
Which of the following statements is true?
A. In an assert statement, the expression after the colon ( : ) can
be any Java expression.
B. If a switch block has no default, adding an assert default is considered appropriate.
C. In an assert statement, if the expression after the colon ( : ) does not have a
value, the assert's error message will be empty.
D. It is appropriate to handle assertion failures using a catch clause.
The right answer is B. To be honest, I answered that question by excluding another obviously wrong cases, but I can't get the point of that question actually. Could anyone explain why it is true? Where can it be helpful?
I guess it means you should protect yourself from missing a switch case.
Say you have an enum Color {red, green} and this switch in the code:
switch(color) {
case red:
doSomethingRed();
break;
case green:
doSomethingGreen();
break;
}
If in the future you add a new color blue, you can forget to add a case for it in the switch.
Adding failing assert to the default case will throw AssertionError and you will discover your mistake .
switch(color) {
case red:
doSomethingRed();
break;
case green:
doSomethingGreen();
break;
default:
assert false : "Oops! Unknown color"
}
This depends on the case but the way I see it
// Consider expecting only 1,2 or 3 as switch case
switch(x)
{
case 1:
// operations
break;
case 2:
// operations
break;
case 3:
// operations
break;
default: assert false : "Input should be between 1-3";
}
Might be convenient as any other input you might receive can be perceived as a faulty input.
Using assert false in switch block's default is applicable in the public method context e.g.
public void methA(int x) throws Exception {
if(x!=1 && x!=2 && x!=3)
throw new IllegalArgumentException("from Exception: x should be between 1,2 and 3");
switch(x)
{
case 1: doSomething(); break;
case 2: doSomething(); break;
case 3: doSomething(); break;
default: assert false : "from default: x should be between 1,2 and 3";
}
}
If the switch block is used in a public method, then checking the value of the argument x is already handled by an exception before the switch statement.
So, even when you use the assert false in default, that code is never reachable, since the assumption that x is 1,2 or 3 is always true. If not true, it is already handled by the IllegalArgumentException before the switch default. So basically, the assumption that switch-default will never be reached is always true. Hence it is appropriate in the context of public method.
I'm looking to make a switch where 5 of the cases are functionally identical, but then there will be other unique cases. Is there a way to list a case value that handles 5 different values? Thanks
You can compound the labels in the switch
switch (variable) {
case 'a': case 'b' : case 'c' : case 'd' :
do something;
break;
case 'e': case 'f' :
do something else
break;
default:
do something;
}
Thinking of a switch as a jump to a label (possibly coupled with a jump (the break) to the end) will help. That means the switch
switch (variable) {
case 'a': case 'b' : case 'c' : case 'd' :
do something;
// note that there's no break here.
case 'e': case 'f' :
do something else
break;
default:
do something;
}
will "do something" and "do something else" for 'a', 'b', 'c', and 'd'; while it will only "do something else" for 'e' and 'f'. Finally if it's not any of the above it hits the default block of "do something".
switch (value) {
case 1:
case 2:
case 3:
case 4:
doSomethingIdentical();
break;
case 5:
doSomethingDifferent();
break;
default:
break;
}
This is very easy to do. Instead of just having one case value that handles all 5 different values, let the 5 case values fall through to each other, like so:
switch(value)
{
case 1:
case 2:
//case 1 and 2 will both result in this code being executed
doSomething();
break;
case 3:
doSomethingElse();
break;
}
As long as you don't put a break; on a switch it will fall through to the next statement.
In that way, you can have something like this:
String value(int val) {
String out = "";
switch(val) {
case 0:
out = "case 0";
break;
case 1:
out = "case 1";
break;
case 2:
case 3:
case 4:
case 5:
case 6:
out = "case 2, 3, 4, 5 or 6";
break;
case 7:
out = "case 7";
break;
}
return out;
}
Yes, just use a switch like this:
switch(v) {
case 1:
case 2:
case 3:
identicFunctionality();
break;
case 4:
other01();
break;
case 5:
other02();
break;
default:
_default();
}
As of Java 12 I believe it is supported. Check out JEP 354. I have never used the syntax but I think it would run like this for your case.
switch (day) {
case 1, 2, 3, 4, 5 -> System.out.println("1-5");
case 7 -> System.out.println(7);
case 8 -> System.out.println(8);
case 9 -> System.out.println(9);
}
on a related note JEP 325 is also cool.