Java Method Basics Cheat Sheet
Uploaded by
TECHNICAL ARPITJava Method Basics Cheat Sheet
Uploaded by
TECHNICAL ARPITCommon questions
Powered by AIWidening type casting in Java is an automatic conversion that converts a smaller primitive type to a larger primitive type, which does not result in data loss. For example, assigning an 'int' value to a 'double' variable is widening: 'int x = 45; double y = x;' . In contrast, narrowing type casting is a manual conversion where a larger primitive type is converted to a smaller primitive type, which may result in data loss. For example, casting a 'double' to an 'int': 'double d = 45.9; int n = (int) d;', this truncates the decimal part .
The 'continue' command in Java is utilized within loops to skip the current iteration and move directly to the next iteration. This is particularly useful when you want to ignore certain conditions in a loop without completely exiting the loop. For example, in a loop where certain values should not be processed, 'continue' can be used to skip further operations for those values and continue with the next iteration of the loop. This allows for efficient conditional evaluation while keeping the loop running .
The main difference between 'while' and 'do-while' loops in Java is when the condition is evaluated. In a 'while' loop, the condition is evaluated before the loop body is executed, meaning the loop body might not run at all if the condition is false initially. Conversely, a 'do-while' loop evaluates the condition after the loop body is executed, guaranteeing that the loop body runs at least once. 'Do-while' is preferable when you need the loop to execute at least once regardless of the condition's initial state .
Starting from Java 7, the 'switch' statement can be used with Strings, enabling more expressive control flows based on string values. This feature increases the flexibility and readability of code that needs to perform different actions based on string content. For example, 'switch(day)' can be used with cases as strings like 'case "Monday":', making it more intuitive than using multiple 'if-else' conditions. This reduces code complexity in scenarios where distinct string values determine the execution path, improving code maintainability and readability .
Using the 'Scanner' class in Java allows for flexible input handling from various sources like input streams. However, issues could arise related to input buffer handling and token parsing. For example, when switching between reading different data types, the Scanner might not consume the newline character correctly, which could lead to unexpected behavior or errors. It is important to handle these scenarios by potentially using 'sc.nextLine()' to clear the buffer after reading numeric input or when changing input types to avoid such discrepancies .
Java provides various string manipulation functions through the java.lang.String class, which allow for modifying and extracting substrings. Methods like 'substring()' allow parts of a string to be extracted, e.g., 's.substring(0, 3)' would extract "Hel" from "Hello". Functions such as 'replace()' can be used to alter string content, e.g., 's.replace("H", "J")' transforms "Hello" to "Jello". These methods provide flexibility in handling strings for detailed text processing tasks .
Escape sequences in Java are used to perform specific character formatting tasks in strings and output operations. They allow control over the display of special characters and formatting without disrupting the flow or causing syntax errors. Examples include '\n' for a newline, '\t' for a tab, '\\' for a backslash, '\"' for a double quote, and '\r' for a carriage return. These are crucial for correct and readable formatting in console output .
Method overloading in Java allows multiple methods to have the same name with different parameters (different type or number of parameters). This enhances code readability and usability, allowing programmers to use the same logic with different input sets. For instance, having two 'sum' methods, one taking integers and another taking doubles, allows you to handle summation seamlessly regardless of the data type input: 'void sum(int a, int b)' and 'void sum(double a, double b)'. This approach avoids creating different function names for similar operations and improves code maintenance .
The 'static' keyword in the context of the 'main' method allows the Java Virtual Machine (JVM) to invoke the method without creating an instance of the class. This is necessary because the 'main' method serves as the entry point of a Java application, and it must be accessible to the JVM directly. If the 'main' method were not static, the JVM would need to instantiate the class before it could call the method, complicating the process of application startup .
Recursion in Java involves a method calling itself to solve a problem. It is characterized by a base case that stops the recursion and a recursive case that reduces the problem size. For example, calculating the factorial of a number can be implemented recursively: 'int fact(int n) { if (n == 0) return 1; return n * fact(n - 1); }'. This method will keep calling itself with decreasing values of 'n' until 'n' reaches 0, at which point it returns 1 and allows the recursive calls to resolve .