Java как написать или

int a = 6;
int b = 3;
int c = 4;
boolean d = (a > b) && (a > c);
System.out.println(d);

--OUTPUT> true

int a = 6;
int b = 4;
int c = 7;
boolean d = (a > b) && (a > c);
System.out.println(d);

--OUTPUT> false

int a = 4;
int b = 5;
int c = 6;
boolean d = (a > b) && (a > c);
System.out.println(d);

--OUTPUT> false

int a = 4;
int b = 6;
int c = 3;
boolean d = (a > b) || (a > c);
System.out.println(d);

--OUTPUT> true

int a = 9;
int b = 9;
boolean c = a > b || a != b;
System.out.println(c);

--OUTPUT> false

int a = 5;
int b = 6;
int c = 7;
boolean d = (b > a) ^ (c > a);
System.out.println(d);

--OUTPUT> false

int a = 5;
int b = 9;
boolean d = !(a > b);
System.out.println(d);

--OUTPUT> true

int a = 3;
int b = 0;

boolean d = (b != 0) && (a/b > 0);
System.out.println(d);

--OUTPUT> false

int a = 3;
int b = 0;

boolean d = (b != 0) & (a/b > 0);
System.out.println(d);

--OUTPUT> Exception in thread <...> java.lang.ArithmeticException: / by zero
	at <...>

public void printStringLengthMoreThenZero(String str) {
   if (str != null && str.length() > 0) {
       System.out.println(str.length());
   } else {
       System.out.println("Тут нечего считать!");
   }
}

boolean a = true ^ true & false;
System.out.println(a);

boolean a = true ^ true && false;
System.out.println(a);

boolean a = (true ^ true) & false;
System.out.println(a);

--OUTPUT> false

int a = 3 & 5;
int b = 3 | 5;
int c = 3 ^ 5;
System.out.println(a);
System.out.println(b);
System.out.println(c);

--OUTPUT> 1
--OUTPUT> 7
--OUTPUT> 6

Научитесь: Профессия Java-developer PRO
Узнать больше

Логические операторы

Логические операторы работают только с операндами типа boolean. Все логические операторы с двумя операндами объединяют два логических значения, образуя результирующее логическое значения. Не путайте с побитовыми логическими операторами.

Таблица логических операторов в Java

Логические операторы &, |, ^ действуют применительно к значениям типа boolean точно так же, как и по отношению к битам целочисленных значений. Логический оператор ! инвертирует (меняет на противоположный) булево состояние: !true == false и !false == true.

Таблица. Результаты выполнения логических операторов

Сокращённые логические операторы

Кроме стандартных операторов AND (&) и OR (|) существуют сокращённые операторы && и ||.

Если взглянуть на таблицу, то видно, что результат выполнения оператора OR равен true, когда значение операнда A равно true, независимо от значения операнда B. Аналогично, результат выполнения оператора AND равен false, когда значение операнда A равно false, независимо от значения операнда B. Получается, что нам не нужно вычислять значение второго операнда, если результат можно определить уже по первому операнду. Это становится удобным в тех случаях, когда значение правого операнда зависит от значения левого.

Рассмотрим следующий пример. Допустим, мы ввели правило — кормить или не кормить кота в зависимости от числа пойманных мышек в неделю. Причём число мышек зависит от веса кота. Чем больше кот, тем больше он должен поймать мышей.

Кот, прочитавший условие задачи, обиделся на меня. Он заявил, что я отстал от жизни, а на дворе 21 век — мышей можно ловить с помощью мышеловок. Пришлось объяснять ему, что это всего лишь задачка, а не пример из личной жизни.

int mouse; // число мышек
int weight; // вес кота в граммах
mouse = 5;
weight = 4500;

if (mouse != 0 & weight / mouse < 1000) {
	mInfoTextView.setText("Можно кормить кота");
}

Если запустить программу, то пример будет работать без проблем — пять мышей в неделю вполне достаточно, чтобы побаловать кота вкусным завтраком. Если он поймает четырёх мышей, то начнутся проблемы с питанием кота, но не с программой — она будет работать, просто не будет выводить сообщение о разрешении покормить дармоеда.

Теперь возьмём крайний случай. Кот обленился и не поймал ни одной мышки. Значение переменной mouse будет равно 0, а в выражении есть оператор деления. А делить на 0 нельзя и наша программа закроется с ошибкой. Казалось бы, мы предусмотрели вариант с 0, но Java вычисляет оба выражения mouse != 0 и weight / mouse < 1000, несмотря на то, что уже в первом выражении возвращается false.

Перепишем условие следующим образом (добавим всего лишь один символ):

if (mouse != 0 && weight / mouse < 1000) {
	mInfoTextView.setText("Можно кормить кота");
}

Теперь программа работает без краха. Как только Java увидела, что первое выражение возвращает false, то второе выражение с делением просто игнорируется.

Сокращённые варианты операторов AND и OR принято использовать в тех ситуациях, когда требуются операторы булевой логики, а их односимвольные родственники используются для побитовых операций.

Тернарный оператор

В языке Java есть также специальный тернарный условный оператор, которым можно заменить определённые типы операторов if-then-else — это оператор ?:

Тернарный оператор использует три операнда. Выражение записывается в следующей форме:

логическоеУсловие ? выражение1 : выражение2

Если логическоеУсловие равно true, то вычисляется выражение1 и его результат становится результатом выполнения всего оператора. Если же логическоеУсловие равно false, то вычисляется выражение2, и его значение становится результатом работы оператора. Оба операнда выражение1 и выражение2 должны возвращать значение одинакового (или совместимого) типа.

Рассмотрим пример, в котором переменной absval присваивается абсолютное значение переменной val.

int absval, val;
val = 5;
absval = val < 0 ? -val : val;

// выводим число
mInfoTextView.setText("" + absval);

val = -5;
absval = val < 0 ? -val : val;

mInfoTextView.setText("" + absval);

Переменной absval будет присвоено значение переменной val, если значение больше или равно нулю (вторая часть выражения). Если значение переменной val отрицательное, то переменной absval присваивается значение переменной, взятое со знаком минус, в результате минус на минус даст плюс, то есть положительно значение. Перепишем код с использованием if-else:

if(val < 0) absval = -val;
else absval = val;

Другой пример с тернарным оператором можете посмотреть здесь.

Реклама

Logical operators are used to performing logical “AND”, “OR” and “NOT” operations, i.e. the function similar to AND gate and OR gate in digital electronics. They are used to combine two or more conditions/constraints or to complement the evaluation of the original condition under particular consideration. One thing to keep in mind is, while using AND operator, the second condition is not evaluated if the first one is false. Whereas while using OR operator, the second condition is not evaluated if the first one is true, i.e. the AND and OR operators have a short-circuiting effect. Used extensively to test for several conditions for making a decision.

1. AND Operator ( && ) – if( a && b ) [if true execute else don’t]
2. OR Operator ( || ) – if( a || b) [if one of them is true execute else don’t]
3. NOT Operator ( ! ) – !(a<b) [returns false if a is smaller than b]

Example For Logical Operator in Java

Here is an example depicting all the operators where the values of variables a, b, and c are kept the same for all the situations.

a = 10, b = 20, c = 30

For AND operator:

Condition 1: c > a                 
Condition 2: c > b         

Output: True [Both Conditions are true]  

For OR Operator:    

Condition 1: c > a 
Condition 2: c > b  

Output: True [One of the Condition if true]

For NOT Operator:
Condition 1: c > a
Condition 2: c > b

Output: False [Because the result was true and NOT operator did it's opposite]

1. Logical ‘AND’ Operator (&&) 

This operator returns true when both the conditions under consideration are satisfied or are true. If even one of the two yields false, the operator results false. In Simple terms, cond1 && cond2 returns true when both cond1 and cond2 are true (i.e. non-zero). 

Syntax:

condition1 && condition2

Illustration:

a = 10, b = 20, c = 20

condition1: a < b
condition2: b == c

if(condition1 && condition2)
d = a + b + c

// Since both the conditions are true
d = 50.

Example

Var1 = 10
Var2 = 20
Var3 = 20
The sum is: 50

Now in the below example, we can see the short-circuiting effect. Here when the execution reaches to if statement, the first condition inside the if statement is false and so the second condition is never checked. Thus the ++b(pre-increment of b) never happens and b remains unchanged.

Example:

Output:

2. Logical ‘OR’ Operator (||) 

This operator returns true when one of the two conditions under consideration is satisfied or is true. If even one of the two yields true, the operator results true. To make the result false, both the constraints need to return false. 

Syntax:

condition1 || condition2

Example:

a = 10, b = 20, c = 20

condition1: a < b
condition2: b > c

if(condition1 || condition2)
d = a + b + c

// Since one of the condition is true
d = 50.

Var1 = 10
Var2 = 1
Var3 = 10
Var4 = 30
One or both + the conditions are true

Now in the below example, we can see the short-circuiting effect for OR operator. Here when the execution reaches to if statement, the first condition inside the if statement is true and so the second condition is never checked. Thus the ++b (pre-increment of b) never happens and b remains unchanged.

Example

Value of b: 20
Inside if
Value of b: 20

3. Logical ‘NOT’ Operator (!)

Unlike the previous two, this is a unary operator and returns true when the condition under consideration is not satisfied or is a false condition. Basically, if the condition is false, the operation returns true and when the condition is true, the operation returns false. 

Syntax:

!(condition)

Example:

a = 10, b = 20

!(a<b) // returns false
!(a>b) // returns true

Var1 = 10
Var2 = 1
!(a < b) = true
!(a > b) = false

4. Implementing all logical operators on Boolean values (By default values – TRUE or FALSE)

Syntax – 

 boolean a = true;
 boolean b = false;

program –

a: true
b: false
a && b: false
a || b: true
!a: false
!b: true

Explanation:

• The code above is a Java program that implements all logical operators with default values. The program defines a class LogicalOperators with a main method.
• In the main method, two boolean variables a and b are defined and assigned default values true and false, respectively.
• The program then prints the values of a and b to the console using the System.out.println method. This allows us to verify the values assigned to a and b.
• Next, the program calculates the result of the logical operators && (and), || (or), and ! (not) applied to a and b. The results of these operations are also printed to the console using the System.out.println method.
• The && operator returns true if both operands are true; otherwise, it returns false. In this case, the result of a && b is false.
• The || operator returns true if either operand is true; otherwise, it returns false. In this case, the result of a || b is true.
• The ! operator negates the value of its operand. If the operand is true, the result is false, and if the operand is false, the result is true. In this case, the results of !a and !b are false and true, respectively.
• The output of the program shows the truth table for all logical operators. This table provides a visual representation of how these operators behave for all possible combinations of true and false inputs.

5. Advantages of logical operators:

The advantages of using logical operators in a program include:

1. Readability: Logical operators make code more readable by providing a clear and concise way to express complex conditions. They are easily recognizable and make it easier for others to understand the code.
2. Flexibility: Logical operators can be combined in various ways to form complex conditions, making the code more flexible. This allows developers to write code that can handle different scenarios and respond dynamically to changes in the program’s inputs.
3. Reusability: By using logical operators, developers can write code that can be reused in different parts of the program. This reduces the amount of code that needs to be written and maintained, making the development process more efficient.
4. Debugging: Logical operators can help to simplify the debugging process. If a condition does not behave as expected, it is easier to trace the problem by examining the results of each logical operator rather than having to navigate through a complex code structure.

Overall, logical operators are an important tool for developers and play a crucial role in the implementation of complex conditions in a program. They help to improve the readability, flexibility, reusability, and debuggability of the code.

Logical operators are used to performing logical “AND”, “OR” and “NOT” operations, i.e. the function similar to AND gate and OR gate in digital electronics. They are used to combine two or more conditions/constraints or to complement the evaluation of the original condition under particular consideration. One thing to keep in mind is, while using AND operator, the second condition is not evaluated if the first one is false. Whereas while using OR operator, the second condition is not evaluated if the first one is true, i.e. the AND and OR operators have a short-circuiting effect. Used extensively to test for several conditions for making a decision.

1. AND Operator ( && ) – if( a && b ) [if true execute else don’t]
2. OR Operator ( || ) – if( a || b) [if one of them is true execute else don’t]
3. NOT Operator ( ! ) – !(a<b) [returns false if a is smaller than b]

Example For Logical Operator in Java

Here is an example depicting all the operators where the values of variables a, b, and c are kept the same for all the situations.

a = 10, b = 20, c = 30

For AND operator:

Condition 1: c > a                 
Condition 2: c > b         

Output: True [Both Conditions are true]  

For OR Operator:    

Condition 1: c > a 
Condition 2: c > b  

Output: True [One of the Condition if true]

For NOT Operator:
Condition 1: c > a
Condition 2: c > b

Output: False [Because the result was true and NOT operator did it's opposite]

1. Logical ‘AND’ Operator (&&) 

This operator returns true when both the conditions under consideration are satisfied or are true. If even one of the two yields false, the operator results false. In Simple terms, cond1 && cond2 returns true when both cond1 and cond2 are true (i.e. non-zero). 

Syntax:

condition1 && condition2

Illustration:

a = 10, b = 20, c = 20

condition1: a < b
condition2: b == c

if(condition1 && condition2)
d = a + b + c

// Since both the conditions are true
d = 50.

Example

Var1 = 10
Var2 = 20
Var3 = 20
The sum is: 50

Now in the below example, we can see the short-circuiting effect. Here when the execution reaches to if statement, the first condition inside the if statement is false and so the second condition is never checked. Thus the ++b(pre-increment of b) never happens and b remains unchanged.

Example:

Output:

2. Logical ‘OR’ Operator (||) 

This operator returns true when one of the two conditions under consideration is satisfied or is true. If even one of the two yields true, the operator results true. To make the result false, both the constraints need to return false. 

Syntax:

condition1 || condition2

Example:

a = 10, b = 20, c = 20

condition1: a < b
condition2: b > c

if(condition1 || condition2)
d = a + b + c

// Since one of the condition is true
d = 50.

Var1 = 10
Var2 = 1
Var3 = 10
Var4 = 30
One or both + the conditions are true

Now in the below example, we can see the short-circuiting effect for OR operator. Here when the execution reaches to if statement, the first condition inside the if statement is true and so the second condition is never checked. Thus the ++b (pre-increment of b) never happens and b remains unchanged.

Example

Value of b: 20
Inside if
Value of b: 20

3. Logical ‘NOT’ Operator (!)

Unlike the previous two, this is a unary operator and returns true when the condition under consideration is not satisfied or is a false condition. Basically, if the condition is false, the operation returns true and when the condition is true, the operation returns false. 

Syntax:

!(condition)

Example:

a = 10, b = 20

!(a<b) // returns false
!(a>b) // returns true

Var1 = 10
Var2 = 1
!(a < b) = true
!(a > b) = false

4. Implementing all logical operators on Boolean values (By default values – TRUE or FALSE)

Syntax – 

 boolean a = true;
 boolean b = false;

program –

a: true
b: false
a && b: false
a || b: true
!a: false
!b: true

Explanation:

• The code above is a Java program that implements all logical operators with default values. The program defines a class LogicalOperators with a main method.
• In the main method, two boolean variables a and b are defined and assigned default values true and false, respectively.
• The program then prints the values of a and b to the console using the System.out.println method. This allows us to verify the values assigned to a and b.
• Next, the program calculates the result of the logical operators && (and), || (or), and ! (not) applied to a and b. The results of these operations are also printed to the console using the System.out.println method.
• The && operator returns true if both operands are true; otherwise, it returns false. In this case, the result of a && b is false.
• The || operator returns true if either operand is true; otherwise, it returns false. In this case, the result of a || b is true.
• The ! operator negates the value of its operand. If the operand is true, the result is false, and if the operand is false, the result is true. In this case, the results of !a and !b are false and true, respectively.
• The output of the program shows the truth table for all logical operators. This table provides a visual representation of how these operators behave for all possible combinations of true and false inputs.

5. Advantages of logical operators:

The advantages of using logical operators in a program include:

1. Readability: Logical operators make code more readable by providing a clear and concise way to express complex conditions. They are easily recognizable and make it easier for others to understand the code.
2. Flexibility: Logical operators can be combined in various ways to form complex conditions, making the code more flexible. This allows developers to write code that can handle different scenarios and respond dynamically to changes in the program’s inputs.
3. Reusability: By using logical operators, developers can write code that can be reused in different parts of the program. This reduces the amount of code that needs to be written and maintained, making the development process more efficient.
4. Debugging: Logical operators can help to simplify the debugging process. If a condition does not behave as expected, it is easier to trace the problem by examining the results of each logical operator rather than having to navigate through a complex code structure.

Overall, logical operators are an important tool for developers and play a crucial role in the implementation of complex conditions in a program. They help to improve the readability, flexibility, reusability, and debuggability of the code.

Логические операторы языка Java выполняются только с операндами типа boolean.

Следующая таблица перечисляет логические операторы языка Java:

1. Логические операторы OR, AND, XOR, NOT.

Начнем с операций OR(|), AND(&), XOR(^), NOT(!). Операторы OR, AND, XOR являются бинарными — они требуют два оператора. NOT — это унарный оператор, только один оператор участвует в операции. Результаты выполнения этих логических операций представлены в следующей таблице:

OR (|) — результат будет true, если хотя бы одно значение равно true. Пример: для того, чтобы забрать ребенка из садика, должна прийти либо мать, либо отец, либо оба — в любом случае результат будет положительный. Если же никто не придет, ребенка не заберут — результат будет отрицательный.

AND (&) — результат будет true, только если и A, и B равны true. Пример: для того чтобы свадьба состоялась, и невеста (A) и жених (B) должны явиться на бракосочетание, иначе оно не состоится.

XOR (^) — результат будет true, только если или A равно true, или В равно true. Пример: у двух друзей на двоих один велосипед, поездка на велосипеде состоится только если один из них поедет на нем. Вдвоем они ехать не могут. 

NOT (!) — инвертирование значения. Если значение было true, то станет false, и наоборот.

Рассмотрим пример использования логических операторов:

public class BooleanLogic1 {
    public static void main(String[] args) {
        boolean a = true;
        boolean b = false;
        boolean c = a | b;
        boolean d = a & b;
        boolean e = a ^ b;
        boolean f = (!a & b) | (a & !b);
        boolean g = !a;
        System.out.println("a = " + a);
        System.out.println("b = " + b);
        System.out.println("a | b = " + c);
        System.out.println("a & b = " + d);
        System.out.println("a ^ b = " + e);
        System.out.println("(!a & b) | (a & !b) = " + f);
        System.out.println("!a = " + g);
    }
}

Чаще всего в языке Java используются так называемые укороченные логические операторы (short-circuit):

||   —  Укороченный логический оператор ИЛИ

&&  — Укороченный логический оператор И

Правый операнд сокращенных операций вычисляется только в том случае, если от него зависит результат операции, то есть если левый операнд конъюнкции имеет значение true, или левый операнд дизъюнкции имеет значение false.

В формальной спецификации языка Java укороченные логические операции называются условными.

public class BooleanLogic2 {
    public static void main(String[] args) {
        int d = 0;
        int num = 10;
        if (d != 0 && num / d > 10) {
            System.out.println("num = " + num);
        }
    }
}

public class BooleanLogic3 {
    public static void main(String[] args) {
        int a = 1;
        int b = 2;
        int x = 3;
        System.out.print(a < x && x < b);
       // System.out.print(a < x < b);//Ошибка компиляции
    }
}

public class BooleanLogic4 {
    public static void main(String[] args) {
        boolean b1 = true;
        boolean b2 = false;
        System.out.println(b1 == b2);
        System.out.println(b1 != b2);
    }
}

public class BooleanLogic5 {
    public static void main(String[] args) {
        boolean b1 = true;
        boolean b2 = true;
        b1 &= b2;//равносильно b1 = b1 & b2;
        System.out.println(b1);
        b1 |= b2; //равносильно b1 = b1 | b2;
        System.out.println(b1);
        b1 ^= b2; //равносильно b1 = b1 ^ b2;
        System.out.println(b1);
    }
}