One of the fundamental elements of many programming languages ​​is conditionals . These designs allow you to direct the work of the program along one of the paths depending on certain conditions.

The following conditional constructs are used in Java: if..else and switch..case

if/else construct

An if/else statement tests the truth of a certain condition and, depending on the results of the test, executes certain code:

Int num1 = 6; int num2 = 4; if(num1>num2)( System.out.println("The first number is greater than the second"); )

After keyword if condition is set. And if this condition is met, then the code that is placed further in the if block after curly braces. The conditions are the operation of comparing two numbers.

Since, in this case, the first number is greater than the second, the expression num1 > num2 is true and returns true. Consequently, control moves to the block of code after the curly braces and begins to execute the instructions contained there, specifically the method System.out.println("The first number is greater than the second"); . If the first number were less than or equal to the second, the statements in the if block would not be executed.

But what if we want some action to also be performed if a condition is not met? In this case we can add an else block:

Int num1 = 6; int num2 = 4; if(num1>num2)( System.out.println("The first number is greater than the second"); ) else( System.out.println("The first number is less than the second");

Int num1 = 6; int num2 = 8; if(num1>num2)( System.out.println("The first number is greater than the second"); ) else if(num1

We can also connect several conditions at once using logical operators:

Int num1 = 8; int num2 = 6; if(num1 > num2 && num1>7)( System.out.println("The first number is greater than the second and greater than 7"); )

Here the if block will be executed if num1 > num2 is true and at the same time num1>7 is true .

Switch construction

Design switch/case is similar to the if/else construct, since it allows you to process several conditions at once:

Int num = 8; switch(num)( case 1: System.out.println("the number is 1"); break; case 8: System.out.println("the number is 8"); num++; break; case 9: System.out. println("the number is 9"); break; default: System.out.println("the number is not 1, 8, 9"); )

After the switch keyword, the expression to be compared comes in parentheses. The value of this expression is sequentially compared with the values ​​placed after the case operator. And if a match is found, then a specific case block will be executed.

A break statement is placed at the end of the case block to avoid executing other blocks. For example, if we removed the break statement in the following case:

Case 8: System.out.println("the number is 8"); num++; case 9: System.out.println("the number is 9"); break;

then since our variable num is equal to 8, then the block case 8 would be executed, but since in this block the variable num is increased by one, there is no break statement, then the block case 9 would begin to be executed.

If we also want to handle the situation where no match is found, we can add a default block, as in the example above. Although the default block is optional.

Starting with JDK 7, in addition to primitive types, you can also use strings in a switch..case expression:

Package firstapp; import java.util.Scanner; public class FirstApp ( public static void main(String args) ( Scanner in = new Scanner(System.in); System.out.println("Enter Y or N: "); String input= in.nextLine(); switch( input)( case "Y": System.out.println("You pressed the letter Y"); break; case "N": System.out.println("You pressed the letter N"); break; default: System.out .println("You pressed an unknown letter"); ) ) )

Ternary operation

The ternary operator has the following syntax: [first operand - condition] ? [second operand] : [third operand] . Thus, three operands are involved in this operation. Depending on the condition, the ternary operator returns a second or third operand: if the condition is true , then the second operand is returned; if the condition is false , then the third one. For example:

Int x=3; int y=2; int z = x

Here the result of the ternary operation is the variable z. First the condition x is checked

Stanislav Gornakov

In order to speak and read any foreign language, you need to learn the alphabet and grammar of that language. A similar condition is observed when studying programming languages, with the only difference, it seems to me, that this process is somewhat easier. But before you start writing the source code of the program, you must first solve the problem assigned to you in any form convenient for you.

Let's create a certain class that is responsible, for example, for a telephone, which will have only two methods: turning on and off this very phone. Since we currently do not know the syntax of the Java language, we will write the Phone class in an abstract language.

Class Phone ( Method Enable() ( // operations to turn on the phone ) Method Disable ( // operations to turn off the phone ) )

The Phone class might look something like this. Note that curly braces indicate the beginning and end of the body of a class, method, or any sequence of data, respectively. That is, parentheses indicate membership in a method or class. For every opening parenthesis there must be a closing parenthesis. To avoid confusion, they are usually placed at the same level in the code.

Now let's write the same class only in Java.

Class Telefon ( void on() ( // method body on() ) void off() ( // method body off() ) )

The keyword class in the Java language declares a class, followed by the name of the class itself. In our case, this is Telefon. Just a few words about the recording register. In almost all programming languages, it is important to save names in the register in which they were written. If you wrote Telefon, then such a spelling as telefon or TELefoN will generate an error during compilation. As we wrote initially, this is how we should continue to write.

Reserved or keywords are written in their own specific case, and you cannot use them by naming them to methods, classes, objects, and so on. Spaces between words don't matter because the compiler simply ignores them, but they are important for code readability.

In the body of the Telefon class there are two methods: on() - turns on the phone and off() method - turns off the phone. Both methods have their own bodies and, in theory, they should contain some source code that describes the necessary actions of both methods. For us now it doesn’t matter how these methods are implemented, the main thing is the syntax of the Java language.

Both methods have on() parentheses within which parameters can be written, such as on(int time) or on(int time, int time1). With the help of parameters, there is a kind of connection between methods and the outside world. The on(int time) method is said to take a time parameter. What is it for? For example, you want your phone to turn on at a certain time. Then the integer value in the time parameter will be passed to the body of the method and, based on the received data, the phone will be turned on. If the parentheses are empty, then the method does not accept any parameters.

Comments

In the Telefon class, in the bodies of both methods there is an entry after two slashes: //. This entry denotes comments that will be ignored by the compiler, but are needed for code readability. The more information you comment on as you write the program, the more likely you will be to remember in a year what you have been working on all this time.

Comments in Java can be of three types: //, /*…*/ and /**…*/. Comments written using the // operator must appear on one line:

// One line!!! Error! You can't wrap it on the second line! // First line // Second line // ... // Last line

Comments using the /*…*/ operators can span multiple lines. At the beginning of your comment, put /*, and at the end, when you finish commenting the code, put the operator */. The last type of comment /**…*/ is used when documenting code and can also be located on any number of lines.

Java Data Types

To set an arbitrary value, Java has data types. In the Telefon class we have created two methods. Both methods had no parameters, but when the example of the on(int time) method with a time parameter was given, they talked about passing a value to the method. This value indicated the time at which the phone supposedly should turn on. The int specifier determines the type of the time value. There are six data types in Java 2 ME.

Byte – small integer value from –128 to 128;
short – short integer value in the range from –32768 to 32767;
int – contains any integer value from –2147483648 to 2147483647;
long – very large integer value, from –922337203685475808 to 9223372036854775807;
char is a Unicode character constant. The range of this format is from 0 to 65536, which is equal to 256 characters. Any character of this type must be written in single quotes, for example: 'G';
boolean is a logical type that has only two values: false and true. This type is often used in loops, which will be discussed later. The meaning is very simple - if you have money in your pocket, it is supposed to be true, and if not, then it is false. Thus, if we have money, we go to the store for bread or beer (underline what is appropriate), if there is no money, we stay at home. That is, this is a logical value that contributes to the choice of further actions of your program.

To declare some necessary value, use the following entry:

Int time; long BigTime; char word;

The semicolon operator is required after entries and is placed at the end of the line. You can combine several declarations of the same type, separated by commas:

Mt time, time1, time2;

Now let's improve our Telefon class by adding some values ​​to it. We no longer need the on() and off() methods; let's add new methods that can actually solve certain problems.

Class Telefon ( //S – display area //w – display width //h – display height int w, h, S; //method that calculates the display area void Area() ( S = w*h; ) )

So, we have three variables S, w and h, which are responsible, respectively, for the area, width and height of the display in pixels. The Area() method calculates the area of ​​the phone's screen in pixels. The operation is useless, but very illustrative and easy to understand. The body of the Area() method has found itself and has the form S = w*h. In this method, we simply multiply the width by the height and assign or, as they say, store the result in the variable S. This variable will contain the values ​​​​of the display area of ​​\u200b\u200bthis phone. Now we have come close to the Java language operators, with which you can perform all kinds of operations and which we will talk about in the next part of this series of articles.

Read also

Office software for a tourism enterprise Automation program for a travel agency self-tour

2023-10-23 00:05:22

VKontakte: quick password recovery is not available

2023-10-22 00:02:31

Autoclickers for mouse and keyboard Download autoclicker is very fast

2023-10-22 00:02:31

Classmates don't work!

2023-10-22 00:02:31