Логические операции. операции отношения. поразрядные логические операции

Условные выражения

Последнее обновление: 16.04.2018

Условные выражения представляют собой некоторое условие и возвращают значение типа boolean, то есть значение true (если условие истинно), или значение false (если условие ложно). К условным выражениям относятся операции сравнения и логические операции.

Операции сравнения

В операциях сравнения сравниваются два операнда, и возвращается значение типа — , если выражение верно, и , если выражение неверно.

  • сравнивает два операнда на равенство и возвращает (если операнды равны) и (если операнды не равны)


    int a = 10;
    int b = 4;
    boolean c = a == b;    		// false
    boolean d = a == 10;       // true
    
  • сравнивает два операнда и возвращает , если операнды НЕ равны, и , если операнды равны

    int a = 10;
    int b = 4;
    boolean c = a != b;    		// true
    boolean d = a != 10;       // false
    
  • < (меньше чем)

    Возвращает , если первый операнд меньше второго, иначе возвращает

    int a = 10;
    int b = 4;
    boolean c = a < b; 	// false
    
  • > (больше чем)

    Возвращает , если первый операнд больше второго, иначе возвращает

    int a = 10;
    int b = 4;
    boolean c = a > b; 	// true
    
  • >= (больше или равно)

    Возвращает , если первый операнд больше второго или равен второму, иначе возвращает

    boolean c = 10 >= 10; 	// true
    boolean b = 10 >= 4; 	// true
    boolean d = 10 >= 20; 	// false
    
  • <= (меньше или равно)

    Возвращает , если первый операнд меньше второго или равен второму, иначе возвращает

    boolean c = 10 <= 10; 	// true
    boolean b = 10 <= 4; 	// false
    boolean d = 10 <= 20; 	// true
    

Логические операции

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

  • (c равно , если либо a, либо b (либо и a, и b) равны , иначе c будет равно )

  • (c равно , если и a, и b равны , иначе c будет равно )

  • (c равно , если b равно , иначе c будет равно )

  • (c равно , если либо a, либо b (но не одновременно) равны , иначе c будет равно )

  • (c равно , если либо a, либо b (либо и a, и b) равны , иначе c будет равно )

  • (c равно , если и a, и b равны , иначе c будет равно )

Здесь у нас две пары операций и (а также и ) выполняют похожие действия, однако же они не равнозначны.

Выражение будет вычислять сначала оба значения — a и b и на их основе выводить результат.

В выражении же вначале будет вычисляться значение a, и если оно равно , то вычисление значения b уже смысла не имеет, так как у нас в любом случае уже c будет равно . Значение b будет вычисляться только в том случае, если a равно

То же самое касается пары операций . В выражении будут вычисляться оба значения — a и b.

В выражении же сначала будет вычисляться значение a, и если оно равно , то вычисление значения b уже не имеет смысла, так как значение c в любом случае равно . Значение b будет вычисляться только в том случае, если a равно

Таким образом, операции и более удобны в вычислениях, позволяя сократить время на вычисление значения выражения и тем самым повышая производительность. А операции и больше подходят для выполнения поразрядных операций над числами.

Примеры:

boolean a1 = (5 > 6) || (4 < 6); // 5 > 6 - false, 4 < 6 - true, поэтому возвращается true
boolean a2 = (5 > 6) || (4 > 6); // 5 > 6 - false, 4 > 6 - false, поэтому возвращается false
boolean a3 = (5 > 6) && (4 < 6); // 5 > 6 - false, поэтому возвращается false (4 < 6 - true, но не вычисляется)
boolean a4 = (50 > 6) && (4 / 2 < 3); // 50 > 6 - true, 4/2 < 3 - true, поэтому возвращается true
boolean a5 = (5 > 6) ^ (4 < 6); // 5 > 6 - true, поэтому возвращается true (4 < 6 - false)
boolean a6 = (50 > 6) ^ (4 / 2 < 3); // 50 > 6 - true, 4/2 < 3 - true, поэтому возвращается false

НазадВперед

Some Common Pitfalls

Using the not operator can sometimes compromise the readability of our code. Negatives can be harder to understand than positives. Let’s look at some examples.

4.1. Double Negatives

Because the not operator is a negation operator, using it with variables or functions that have a negative name, can result in hard to read code. This is similar to natural languages, where double negatives are often considered hard to understand.


For example:

reads better than

While our API may not provide an isActive method, we can create one to aid readability.

4.2. Complex Conditions

The not operator can sometimes make an already complex expression even more difficult to read and understand. When this happens, we can simplify the code by reversing the condition or by extracting methods. Let’s look at some examples of conditions made complex by the not operator and how we can simplify them by reversing the condition:

if statement

Again take the example of raining. If it is raining, a person will take an umbrella.

This type of decision taking is done using if statement in Java.

Let’s have a look at the syntax of if statement before looking at its example.

if(expression)   {     statements   }

If the expression written within the brackets of if statement is true, then the statements written in the body of the if ( enclosed by curly brackets ) are executed.

class D1{
public static void main(String[] args){
  int a=10,b=20;
  if(a < b){
	System.out.println("b is greater than a");
   }
}
}

Output

b is greater than a

Here, the condition of if ( a < b ) is true. So, the statement inside if got executed and b is greater than a got printed on the screen.

Nested IF Statements

You can nest IF Statements. (This also applies to IF … ELSE and IF … ELSE IF statements.) Nesting an IF Statement just means putting one IF Statement inside of another. For example, suppose you want to find out if somebody is younger than 18, but older than 16. You want to display a different message for the over 16s. You start with the first IF Statement:

if ( user < 19 ) {System.out.println( «18 or younger»);}

To check for over 16, you can place a second IF Statement inside of the one you already have. The format is the same:

if ( user < 19 ) {if ( user > 16 && user < 19 ) {System.out.println( «You are 17 or 18»);} }

So the first IF Statement catches the user variable if it’s less than 19. The second IF Statement narrows the user variable down even further, for ages over 16 and under 19. To print different messages, you can have an IF … ELSE statement instead of the IF Statement above:

if ( user < 19 ) {

if ( user > 16 && user < 19 ) {System.out.println( «You are 17 or 18»);}else {System.out.println( «16 or younger»);}

}

Notice where all the curly brackets are in the code: get one wrong and your programme won’t run.

Nested IF Statements can be tricky, but all you’re trying to do is to narrow down the choices.

In the next section, you’ll about the Boolean variable type.

<— If Statements | Boolean Values —>

1.1 Внешние ресурсы

Иногда в процессе работы Java-программа взаимодействует с объектами вне Java-машины. Например, с файлами на диске. Такие объекты принято называть внешними ресурсами. Внутренние ресурсы — это объекты, созданные внутри Java-машины.

Обычно взаимодействие происходит по такой схеме:

Учет ресурсов

Операционная система ведет строгий учет доступных ресурсов, а также контролирует совместный доступ разных программ к ним. Например, если одна программа меняет какой-то файл, другая программа не может изменить (или удалить) этот файл. Это касается не только файлов, но на их примере понятнее всего.

У операционной системы есть функции (API), которые позволяют программе захватить какой-либо ресурс и/или освободить его. Если ресурс занят, с ним может работать только та программа, которая его захватила. Если ресурс свободен, любая программа может захватить его.

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

Захват внешних ресурсов

Каждый раз, когда ваша Java-программа начинает работать с каким-то файлом на диске, Java-машина запрашивает у операционной системы монопольный доступ к нему. Если ресурс свободен, его захватывает Java-машина.

Но после того, как вы закончили работать с файлом, этот ресурс (файл) нужно освободить: уведомить операционную систему, что он вам больше не нужен. Если вы этого не сделаете, ресурс будет продолжать числиться за вашей программой.

Для каждой запущенной программы операционная система ведет список занятых ресурсов. Если ваша программа превысит разрешенный ей лимит ресурсов, новые ресурсы операционная система вам уже не даст.

Хорошая новость в том, что если ваша программа завершилась, все ресурсы автоматически освобождаются (это делает сама операционная система).

Плохая же новость в том, что если вы пишите серверное приложение (а очень много серверных приложений пишутся на Java), ваш сервер должен работать днями, неделями, месяцами без остановки. И если вы в день открываете 100 файлов и не закрываете их, через пару недель ваше приложение исчерпает свой лимит и упадет. Не очень-то похоже на месяцы стабильной работы.

Правила переопределения метода equals в Java


Какие правила существуют для правильного переопределения метода equals? Их пять.

  • Рефлексивность: для каждого ненулевого объекта х выражение x.equals(x) должно возвращать логическое значение true.
  • Симметричность: для всех ненулевых объектов х и у выражение x.equals(y) должно возвращать значение true тогда и только тогда, когда y.equals(x) возвратит true.
  • Транзитивность: для всех трёх ненулевых объектов х, у и z, если х.equals(y) возвращает логическое true и у.equals(z) возвращает true, то и выражение х.equals(z) должно всегда возвращать true.
  • Непротиворечивость: если для всех ненулевых объектов х и у несколько раз вызвать х.equals(у), то всегда должно возвращаться значение true (либо false), при условии, что никакая информация,содержащаяся в объектах, не поменялась.
  • И последнее: для всех ненулевых х выражение х.equals(null) должно всегда возвращать логическое значение false.

Если у вас нет склонности к математике, то всё это выглядит страшным, не так ли? Но вчитайтесь несколько раз и разберитесь с вышесказанным. На самом деле всё очень просто. Данные правила нарушать нельзя. В противном случае вы рискуете обнаружить, что ваше приложение работает неустойчиво, неправильно или завершается с ошибкой, а установить источник ошибок такого класса крайне затруднительно.

Поделиться в соц. сетях:

The if-else Statement

Let’s start with a simple if-else statement:

What if our program only needs to handle the negative case? How would we re-write the above example?

One option is to simply remove the code in the if block:

However, an empty if block looks like it might be incomplete code, and seems a long-winded way of handling only the negative condition. We might instead try testing if our logical expression evaluates to false:

The above version is relatively easy to read, though it might be harder to do if the logical expression were more complex. Java has an alternative for us, though, in the form of the not operator:

4.2 Проверяемые исключения: throws, checked exceptions

Все исключения в Java делятся на 2 категории — проверяемые () и непроверяемые ().

Все исключения, унаследованные от классов и , считаются -исключениями, все остальные — -исключениями.

Важно. Спустя 20 лет после введения проверяемых исключений, почти все Java-программисты считают это ошибкой

95% всех исключений в популярных современных фреймворках — непроверяемые. Тот же язык C#, который чуть ли не скопировал Java подчистую, не стал добавлять -исключения.

В чем же основное отличие -исключений от ?

К -исключениям есть дополнительные требования. Звучат они примерно так.

Требование 1

Если метод выбрасывает -исключение, он должен содержать тип этого исключения в своем заголовке (сигнатуре метода)

Чтобы все методы, которые вызывают данный метод, знали о том, что в нем может возникнуть такое «важное исключение»

Указывать -исключения надо после параметров метода после ключевого слова (не путать со ). Выглядит это примерно так:

Пример:

checked-исключение unchecked-исключение

В примере справа наш код выкидывает -исключение — никаких дополнительных действий не нужно. В примере слева метод выкидывает -исключение, поэтому в сигнатуру метода добавили ключевое слово throws и указали тип исключения.

Если метод планирует выкидывать несколько -исключений, все их нужно указать после ключевого слова throws через запятую. Порядок неважен. Пример:

Требование 2

Если вы вызываете метод, у которого в сигнатуре прописаны -исключения, то вы не можете проигнорировать этот факт.

Вы должны либо перехватить все эти исключения, добавив блоки для каждого из них, либо добавить их в  своего метода.


Мы как бы говорим себе: эти исключения настолько важные, что мы обязательно должны их перехватить. А если мы не знаем, как их перехватить, мы должны уведомить тех, кто будет вызывать наш метод, что в нем могут возникнуть такие исключения.

Пример:

Представим, что мы пишем метод, который должен создать мир, населенный людьми. Начальное количество человек передается в качестве параметра. Тогда мы должны добавить исключения, если людей слишком мало.

Создаем Землю Примечание
Метод потенциально кидает два -исключения:
  • ПустойМир
  • ОдинокийМир

Вызов этого метода можно обработать 3 способами:

Не перехватываем возникающие исключения.

Чаще всего это делается в случае, когда в методе не известно, как правильно обработать эту ситуацию.

Код Примечание
Вызывающий метод не перехватывает исключения и вынужден информировать о них других: добавить их себе в

Перехватывать часть исключений.

Обрабатываем понятные ошибки, непонятные — прокидываем в вызывающий метод. Для этого нужно добавить их название в throws:

Код Примечание
Вызывающий метод перехватывает только одно -исключение – , второе он должен добавить в свою сигнатуру: указать после слова

Перехватываем все исключения.

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

Код Примечание
В этом методе перехватываются все ошибки. Вызывающий метод будет уверен, что все прошло отлично.

Java IF ELSE IF

You can test for more than two choices. For example, what if we wanted to test for more age ranges, say 19 to 39, and 40 and over? For more than two choices, the IF ELSE IF statement can be used. The structure of an IF ELSE IF is this:

if ( condition_one ) {

}else if ( condition_two ) {

}else {

}

The new part is this:

else if ( condition_two ) {

}

So the first IF tests for condition number one (18 or under, for example). Next comes else if, followed by a pair of round brackets. The second condition goes between these new round brackets. Anything not caught by the first two conditions will be caught be the final else. Again, code is sectioned off using curly brackets, with each if, else if, or else having its own pair of curly brackets. Miss one out and you’ll get error messages.

Before trying out some new code, you’ll need to learn some more conditional operators. The ones you have used so far are these:

> Greater Than< Less Than>= Greater Than or Equal To<= Less Than or Equal To

Here’s four more you can use:

&& AND|| OR== HAS A VALUE OF! NOT

The first one is two ampersand symbols, and is used to test for more than one condition at the same time. We can use it to test for two age ranges:

else if ( user > 18 && user < 40 )

Here, we want to check if the user is older than 18 but younger than 40. Remember, we’re trying to check what is inside of the user variable. The first condition is «Greater than 18» ( user > 18 ). The second condition is «Less than 40» ( user < 40). In between the two we have our AND operator ( &&). So the whole line says «else if user is greater than 18 AND user is less than 40.»

We’ll get to the other three conditional operators in a moment. But here’s some new code to try out:

Run your programme and test it out. You should be able to guess what it will print out before running it. Because we have a value of 21 for the user variable the message between the curly brackets of else if will display in the Output window.

Exercise Change the value of the user variable from 21 to 45. The message for the else section of the code should now display.

You can add as many else if parts as you want. Suppose we wanted to check if the user was either 45 or 50. We can use two of the new conditional operators above. We can check if the user variable «has a value of 45» OR «has a value of 50»:

else if (user == 45 || user == 50)

To test if the user variable has a value of something you use two equal signs, with no space between them. Java will test for that value and no other values. Because want to test for the user being 50 as well, we can have another condition in the same round brackets: user == 50. This just says «test if the user variable has a value of 50». In between the two conditions, we have the OR operator. This is two pipe characters, which is just to the left of the letter «z» on a UK keyboard. Again, there’s no space between the two. The whole of the line above says «Else if the user has a value of 45 OR the user has a value of 50».

Here’s our code with the new else if part:

Try it out for yourself. Change the value of the user variable to 45 and run your code. Then change it to 50 and run the code again. In both cases the new message should display.

The various conditional operators can be tricky to use. But you’re just testing a variable for a particular condition. It’s simply a question of picking the right conditional operator or operators for the job.


С этим читают