Default statement in java

default keyword in Java

Basically, there are 3 places you can use the default keyword in Java:

1. Specify the default value in a switch case statement
2. Declare default values in a Java annotation
3. Declare default method in an interface

In the following method, the default keyword is used in as switch case statement to return the default value for other cases:

public static int getDaysOfMonth(int month) < switch (month) < case 2: return 28; case 4: case 6: case 9: case 11: return 30; default: return 31; >>

In the following example, the default keyword is used to declare default value for a method in a custom annotation class:

public @interface Editable

And lastly, the default keyword is used to declare a default method in an interface. For example:

The purpose of default method is to add new methods to an interface that will not break the existing subtypes of that interface.

Related Tutorials:

Other Recommended Tutorials:

About the Author:

Nam Ha Minh is certified Java programmer (SCJP and SCWCD). He started programming with Java in the time of Java 1.4 and has been falling in love with Java since then. Make friend with him on Facebook and watch his Java videos you YouTube.

Add comment

Comments

CodeJava.net shares Java tutorials, code examples and sample projects for programmers at all levels.
CodeJava.net is created and managed by Nam Ha Minh — a passionate programmer.

Copyright © 2012 — 2023 CodeJava.net, all rights reserved.

Источник

The switch Statement

Unlike if-then and if-then-else statements, the switch statement can have a number of possible execution paths. A switch works with the byte , short , char , and int primitive data types. It also works with enumerated types (discussed in Enum Types), the String class, and a few special classes that wrap certain primitive types: Character , Byte , Short , and Integer (discussed in Numbers and Strings).

The following code example, SwitchDemo , declares an int named month whose value represents a month. The code displays the name of the month, based on the value of month , using the switch statement.

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; case 4: monthString = "April"; break; case 5: monthString = "May"; break; case 6: monthString = "June"; break; case 7: monthString = "July"; break; case 8: monthString = "August"; break; case 9: monthString = "September"; break; case 10: monthString = "October"; break; case 11: monthString = "November"; break; case 12: monthString = "December"; break; default: monthString = "Invalid month"; break; >System.out.println(monthString); > >

In this case, August is printed to standard output.

The body of a switch statement is known as a switch block. A statement in the switch block can be labeled with one or more case or default labels. The switch statement evaluates its expression, then executes all statements that follow the matching case label.

You could also display the name of the month with if-then-else statements:

int month = 8; if (month == 1) < System.out.println("January"); >else if (month == 2) < System.out.println("February"); >. // and so on

Deciding whether to use if-then-else statements or a switch statement is based on readability and the expression that the statement is testing. An if-then-else statement can test expressions based on ranges of values or conditions, whereas a switch statement tests expressions based only on a single integer, enumerated value, or String object.

Another point of interest is the break statement. Each break statement terminates the enclosing switch statement. Control flow continues with the first statement following the switch block. The break statements are necessary because without them, statements in switch blocks fall through: All statements after the matching case label are executed in sequence, regardless of the expression of subsequent case labels, until a break statement is encountered. The program SwitchDemoFallThrough shows statements in a switch block that fall through. The program displays the month corresponding to the integer month and the months that follow in the year:

public class SwitchDemoFallThrough < public static void main(String[] args) < java.util.ArrayListfutureMonths = new java.util.ArrayList(); int month = 8; switch (month) < case 1: futureMonths.add("January"); case 2: futureMonths.add("February"); case 3: futureMonths.add("March"); case 4: futureMonths.add("April"); case 5: futureMonths.add("May"); case 6: futureMonths.add("June"); case 7: futureMonths.add("July"); case 8: futureMonths.add("August"); case 9: futureMonths.add("September"); case 10: futureMonths.add("October"); case 11: futureMonths.add("November"); case 12: futureMonths.add("December"); break; default: break; >if (futureMonths.isEmpty()) < System.out.println("Invalid month number"); >else < for (String monthName : futureMonths) < System.out.println(monthName); >> > >

This is the output from the code:

August September October November December

Technically, the final break is not required because flow falls out of the switch statement. Using a break is recommended so that modifying the code is easier and less error prone. The default section handles all values that are not explicitly handled by one of the case sections.

The following code example, SwitchDemo2 , shows how a statement can have multiple case labels. The code example calculates the number of days in a particular month:

class SwitchDemo2 < public static void main(String[] args) < int month = 2; int year = 2000; int numDays = 0; switch (month) < case 1: case 3: case 5: case 7: case 8: case 10: case 12: numDays = 31; break; case 4: case 6: case 9: case 11: numDays = 30; break; case 2: if (((year % 4 == 0) && !(year % 100 == 0)) || (year % 400 == 0)) numDays = 29; else numDays = 28; break; default: System.out.println("Invalid month."); break; >System.out.println("Number of Days = " + numDays); > >

This is the output from the code:

Using Strings in switch Statements

In Java SE 7 and later, you can use a String object in the switch statement’s expression. The following code example, StringSwitchDemo , displays the number of the month based on the value of the String named month :

public class StringSwitchDemo < public static int getMonthNumber(String month) < int monthNumber = 0; if (month == null) < return monthNumber; >switch (month.toLowerCase()) < case "january": monthNumber = 1; break; case "february": monthNumber = 2; break; case "march": monthNumber = 3; break; case "april": monthNumber = 4; break; case "may": monthNumber = 5; break; case "june": monthNumber = 6; break; case "july": monthNumber = 7; break; case "august": monthNumber = 8; break; case "september": monthNumber = 9; break; case "october": monthNumber = 10; break; case "november": monthNumber = 11; break; case "december": monthNumber = 12; break; default: monthNumber = 0; break; >return monthNumber; > public static void main(String[] args) < String month = "August"; int returnedMonthNumber = StringSwitchDemo.getMonthNumber(month); if (returnedMonthNumber == 0) < System.out.println("Invalid month"); >else < System.out.println(returnedMonthNumber); >> >

The output from this code is 8 .

The String in the switch expression is compared with the expressions associated with each case label as if the String.equals method were being used. In order for the StringSwitchDemo example to accept any month regardless of case, month is converted to lowercase (with the toLowerCase method), and all the strings associated with the case labels are in lowercase.

Note: This example checks if the expression in the switch statement is null . Ensure that the expression in any switch statement is not null to prevent a NullPointerException from being thrown.

Источник

Mastering the Default Statement in Switch Case Java: Best Practices and Common Issues

Learn about the role and placement of the default statement in switch case in Java. Understand best practices, common issues, and debugging tips. Improve your Java programming skills now!

• What is the default statement in switch case?
• Why should we use a default case in switch statements?
• How does the switch statement work in Java?
• Common issues and errors faced while using switch statements
• Advantages and disadvantages of using switch statements
• Other code examples for the default statement in Java switch case
• Conclusion
• What is default in switch case Java?
• Is default mandatory in switch case Java?
• What is default in switch case?
• What happens if default is first in switch case?

Switch statements are an essential part of Java programming, and they enable you to execute one statement from multiple conditions. The optional default case is executed if none of the case constant-expression values are equal to the value of the expression. In this blog post, we will explain the role and placement of the default statement in switch case in java .

What is the default statement in switch case?

The default statement is an optional statement that can appear anywhere inside the switch block. It is executed if none of the case constant-expression values are equal to the value of the expression. It is best practice to keep the default statement at the end of the switch block. A break statement must be kept after the default statement if it is not at the end to omit the execution of the next case statement.

Why should we use a default case in switch statements?

It is not necessary to have a default case, but it is a good idea to have one. The default case can be used for performing a task when none of the cases are true. The statements written above cases are never executed. best practices for using switch statements in Java include using a default case.

How does the switch statement work in Java?

The switch statement works with byte, short, int, long, enum types, and String objects. The switch expression is evaluated once. The value of the expression is compared with the values of each case. There can be at most one default statement. The position of the default case doesn’t matter; it is executed if no match is found. The switch statement works similarly in C/C++.

Common issues and errors faced while using switch statements

Debugging switch statements can be tricky. A common mistake is to forget to use a break statement, which can lead to unexpected results. Another issue is when there are multiple cases with the same value, which can cause confusion. It is essential to ensure that the switch statement is correctly structured and that all cases are accounted for.

Advantages and disadvantages of using switch statements

switch statements in java have several advantages. They are easy to read and maintain, and they can improve the performance of your code. However, they also have several disadvantages, including limited functionality and the potential for unexpected behavior . It is essential to understand the advantages and disadvantages of using switch statements before deciding whether to use them in your code.

Other code examples for the default statement in Java switch case

In Java , java switch code example

int day = 4; switch (day) < case 6: System.out.println("Today is Saturday"); break; case 7: System.out.println("Today is Sunday"); break; default: System.out.println("Looking forward to the Weekend"); >// Outputs "Looking forward to the Weekend"

In Java as proof, java switch case code sample

In Java , for instance, default case in Java switch-case code example

In Java , for example, syntax of the switch statement in java code sample

In Java as proof, how to use a switch statement in java code sample

case 6: System.out.println("Today is Saturday"); break; case 7:

Conclusion

Using the default statement in switch case is optional, but it is a good practice to use it. The default statement is executed if none of the case constant-expression values are equal to the value of the expression. The switch statement works with byte, short, int, long, enum types, and String objects. The position of the default case doesn’t matter; it is executed if no match is found. best practices for using switch statements in java include keeping the default statement at the end of the switch block and using a break statement after the default statement.

In conclusion, mastering the default statement in switch case in Java is crucial for any developer. Understanding the role and placement of the default statement can help you write cleaner and more efficient code. By following the best practices and being aware of common issues, you can ensure that your code is robust and reliable.

Источник