Главная страница

Презентация по Программированию. Книга Программирование на Java для начинающих


Скачать 4.47 Mb.
НазваниеКнига Программирование на Java для начинающих
АнкорПрезентация по Программированию
Дата03.02.2022
Размер4.47 Mb.
Формат файлаpdf
Имя файла638767.pdf
ТипКнига
#350143
страница4 из 18
1   2   3   4   5   6   7   8   9   ...   18
true, если значения операндов равны. Если операнды являются одними и теми же числами, то они равны; если они являются строками, содержащими одни и те же символы в одном и том же порядке, то они тоже равны.
Операнды логического типа равны, если оба содержат true или оба со- держат false.
Оператор неравенства != наоборот, возвращает true, если значения операндов не равны, используя те же правила, что и оператор равен- ства.
Операторы равенства и неравенства часто применяются для выполне- ния так называемого условного ветвления в программе, когда в зави- симости от условия выбирается дальнейшее направление работы про- граммы.
Оператор «больше» (>) сравнивает два операнда и возвращает true, если значение первого больше, чем значение второго.
Оператор «меньше» (<) делает то же самое сравнение, но возвращает
true
в случае, если значение первого операнда меньше.
Операторы «больше либо равно» и «меньше либо равно» возвращают также значение true, если значения обоих операндов равны.
Выполните следующие шаги для создания Java-программы, выполняю- щей различные операции сравнения.
Совет
Оператор меньше < обычно используется для проверки значения счетчика в цикле – пример вы можете найти в главе 3.

33
1. Создайте новую программу с именем Comparison, содержащую стандартный метод main.
class
Comparison
{
public static void main( String[] args ) { }
}
2. Внутри фигурных скобок главного метода добавьте следующие строки кода для сравнения двух строковых переменных на равен- ство.
String txt = "Fantastic " ;
String lang = "Java" ;
boolean state = ( txt == lang ) ; // Присваиваем результат проверки
System.out.println( "Проверка строк на равенство: " + state ) ;
3. Добавьте следующие строки для проверки на неравенство.
state = ( txt != lang ) ; // Присваиваем ре
зультат
System.out.println( " Проверка строк на неравенство: " + state ) ;
4. Теперь добавьте строки для сравнения двух целочисленных пере- менных.
int dozen = 12 ;
int score = 20 ;
state = ( dozen > score ) ; // Присваиваем результат
System.out.println( "Проверка на больше: " + state ) ;
5. Добавьте еще две строки для сравнения целочисленных перемен- ных еще раз.
state = ( dozen < score ) ; // Присваиваем результат
System.out.println( " Проверка на меньше: " + state ) ;
6. Сохраните программу под именем Comparison.java, затем скомпи- лируйте и запустите.
JAVA
Comparison.java
Совет
Обратите внимание, что про- веряемое выражение можно заключить в скобки для лучшей читаемости.
На заметку
В данном случае неверно
(false), что строковые значе- ния равны, но верно (true), что они не равны.

2. Выполнение операций
34
Оценочная логика
Логические операторы, перечисленные в таблице ниже, используются чтобы объединить несколько выражений, каждое из которых возвра- щает логическое значение, в одно сложное выражение, которое будет возвращать единственное логическое значение.
Оператор
Операция
&&
Логическое И
||
Логическое ИЛИ
!
Логическое НЕ (отрицание)
Логические операторы работают с операндами, имеющими значение логического (булевого ) типа, то есть true или false, либо со значения- ми, которые преобразуются в true или false.
Оператор «логическое И» (&&) оценивает два операнда и возвращает значение true, только если оба операнда сами имеют значение true, в противном случае оператор возвращает значение false. Этот опера- тор обычно используется при условном ветвлении, когда направление работы программы определяется проверкой двух условий: если оба они верны, программа идет в определенном направлении, в противном случае — в другом.
В отличие от оператора and, которому необходимо, чтобы оба операн- да имели значение true, оператор «логическое ИЛИ» (||) оценивает два операнда и возвращает true, если хотя бы один из них сам возвраща- ет значение true. В противном случае оператор || возвратит значение
false
. Это полезно использовать при программировании определенных действий в случае выполнения одного из двух проверяемых условий.
Оператор «логическое НЕ» (!) является унарным и используется с од- ним операндом. Он возвращает противоположное значение от того, какое имел операнд. Так, если переменная a имела значение true, то
!a
возвратит значение false. Он может использоваться, например, для переключения значения переменной в последовательных итерациях цикла при помощи выражения a=!a. Это значит, что на каждой итера- ции цикла логическое значение меняется на противоположное, подоб- но выключению и включению лампочки.
Выполните следующие шаги для создания Java-программы, использую- щей три логических оператора.
1. Создайте новую программу с именем Logic, содержащую стандарт- ный метод main.

35
class
Logic
{
public static void main( String[] args ) { }
}
2. Внутри фигурных скобок главного метода добавьте следующие строки с объявлением и инициализацией двух переменных логиче- ского типа.
boolean yes = true ;
boolean no = false ;
3. Добавьте строки, содержащие проверки двух условий на их истин- ность.
System.out.println(
"Результат выражения yes И yes: " + ( yes && yes ) ) ;
System.out.println( " Результат выражения yes И no: " + ( yes && no ) ) ;
4. Добавьте строки для проверки, что одно из двух условий истинно.
System.out.println(
" Результат выражения yes ИЛИ yes: " + ( yes || yes ) ) ;
System.out.println(
" Результат выражения yes ИЛИ no: " + ( yes || no ) ) ;
System.out.println( "Результат выражения no ИЛИ no: " + ( no || no ) ) ;
5. Добавьте строки, показывающие первоначальное и противополож- ное значения логической переменной.
System.out.println(
"Первоначальное значение переменной yes: " + yes ) ;
System.out.println( "Инвертированная переменная yes: " + !yes ) ;
6. Сохраните программу под именем Logic.java, затем скомпилируйте и запустите.
JAVA
Logic.java
Совет
Логический тип данных
(boolean) назван в честь ма- тематика Джорджа Буля — создателя логической алгебры.

2. Выполнение операций
36
Проверка условий
Наверное, одним из самых любимых Java-программистами операторов является условный оператор, который делает объемную конструкцию очень краткой. Хотя его необычный синтаксис кажется на первый взгляд слишком запутанным, все равно стоит познакомиться с этим полезным оператором.
Условный оператор вначале оценивает выражение на предмет значе- ний true или false, а затем возвращает один из двух своих операндов в зависимости от результатов оценки. Его синтаксис выглядит следую- щим образом:
(
логическое-выражение ) ? если-истина-возвращаем-это : если-ложь-возвращаем-это;
Каждый из указанных операндов является альтернативной веткой ис- полнения программы в зависимости от логической величины, возвра- щаемой проверочным выражением. Например, в качестве вариантов могут возвращаться строковые значения:
status = ( quit == true ) ? "Готово!" : "В процессе..." ;
В данном случае, когда переменная quit содержит значение true, услов- ный оператор присваивает значение своего первого операнда (Готово!) переменной status, а в противном случае оператор присваивает ей зна- чение второго операнда (В процессе...).
Когда проверяется простая логическая величина, то доступна краткая запись проверочного выражения, в этом случае можно опустить сим- волы == true. Таким образом, вышеприведенный пример может быть записан в виде:
status = ( quit ) ? " Готово!" : " В процессе..." ;
Условный оператор может возвращать значение любого типа данных и использовать любое действительное проверочное выражение. На- пример, для оценки двух числовых значений может использоваться оператор сравнения > и возвращаться логическое значение в зависи- мости от результата:
busted = ( speed > speedLimit ) ? true : false ;
Аналогично в проверочном выражении может использоваться опера- тор неравенства != для оценки строковой величины и возвращать, на- пример, числовое значение в зависимости от результата:
bodyTemperature = ( scale != "Celsius" ) ? 98.6 : 37.0 ;
Выполните следующие шаги для создания Java-программы, использую- щей условный оператор.
Совет
Условный оператор также называют «тернарным».

37
1. Создайте новую программу с именем Condition, содержащую стан- дартный метод main.
class
Condition
{
public static void main( String[] args ) { }
}
2. Внутри фигурных скобок главного метода добавьте следующие строки, объявляющие и инициализирующие две целочисленные переменные.
int num1 = 1357 ;
int num2 = 2468 ;
3. Далее объявите строковую переменную для хранения результата проверки.
String result ;
4. Добавьте строки для определения, является ли значение первой переменной четным или нечетным числом, также добавьте вывод результата.
result = ( num1 % 2 != 0 ) ? "Нечетное" : "Четное" ;
System.out.println( num1 + " - " + result ) ;
5. Добавьте следующие строки для аналогичной проверки значения второй целочисленной переменной.
result = ( num2 % 2 != 0 ) ? " Нечетное " : " Четное " ;
System.out.println( num2 + " - " + result ) ;
6. Сохраните программу под именем Condition.java, затем скомпили- руйте и запустите.
JAVA
Condition.java
На заметку
В данном случае выражение будет истинным, когда есть какой-либо остаток.

2. Выполнение операций
38
Приритет операций
Сложные составные выражения, которые содержат несколько операто- ров и операндов, могут быть двусмысленными до тех пор, пока не опре- делить, в каком порядке выполнять операции. Такая неясность может привести к тому, что одно и то же выражение даст разные результаты.
Например, выражение:
num = 8 + 4 * 2 ;
Если выполнять операции слева направо, то 8 + 4 = 12 и 12 * 2 = 24.
Таким образом, num = 24. Если действовать справа налево, то 2 * 4 =
8
, и 8 + 8 = 16. Таким образом, num = 16.
Java-программисты могут с помощью скобок явно указывать, какая из операций будет выполняться первой, заключая в скобки оператор, ко- торый имеет более высокий приоритет. В таком случае (8 + 4) * 2 означает, что сложение будет выполняться перед умножением, и в ре- зультате будет получаться 24, а не 16. И наоборот, 8 + (4 * 2) выпол- няет вначале умножение и результатом будет 16.
В случае, когда порядок операторов явно не указан, используется при- оритет операторов, заданный по умолчанию, который представлен в таблице ниже. Здесь представлены операторы в порядке убывания приоритетов.
Оператор
Описание
++ -- !
Инкремент, декремент, логическое НЕ
* / %
Умножение, деление, деление по модулю
+ -
Сложение, вычитание
> >= < <=
Больше, больше или равно, меньше, меньше или равно
== !=
Равно, не равно
&&
Логическое И
||
Логическое ИЛИ
? :
Тернарная условная операция
= += -= *= /= %=
Присваивание
Выполните следующие шаги для создания Java-программы, работаю- щей с различным приоритетом операторов.
Совет
Операторы, имеющие одинаковый приоритет, об- рабатываются в порядке их появления в выражении — слева направо.

39
1. Создайте новую программу с именем Precedence, содержащую стандартный метод main.
class
Precedence
{
public static void main( String[] args ) { }
}
2. Внутри фигурных скобок главного метода добавьте следующий код для объявления и инициализации целочисленной переменной, со- держащей результат выражения, используя приоритет операторов по умолчанию.
int sum = 32 - 8 + 16 * 2 ; // 16 x 2 = 32, + 24 = 56
System.out.println( "Порядок действий по умолчанию: " + sum ) ;
3. Добавьте строки для присваивания переменной результата того же самого выражения, но с заданием приоритета для операций вычи- тания и сложения.
sum = ( 32 - 8 + 16 ) * 2 ; // 24 + 16 = 40, x 2 = 80
System.out.println( " Указанный порядок действий: " + sum ) ;
4. Добавьте следующие строки, в которых в переменную заносится результат выражения, где задан приоритет операций по убыванию: сначала сложение, затем вычитание, потом умножение.
sum = ( 32 - (8 + 16) ) * 2 ; // 32 - 24 = 8, * 2 = 16
System.out.println( " Специфичный порядок действий: " + sum ) ;
5. Сохраните программу под именем Precedence.java, затем скомпили- руйте и запустите.
JAVA
Precedence.java
На заметку
При использовании вложен- ных скобок в выражениях высший приоритет имеют внутренние скобки.

2. Выполнение операций
40
Управляющие литералы
Числовые и текстовые значения в Java-программах известны как «лите- ралы » — на самом деле они ничего собой не представляют, это просто символы, которые вы видите.
Литералы обычно отделяются от ключевых слов Java-языка, но там, где требуются двойные или одинарные кавычки внутри строковой пере- менной, необходимо указать, что символ кавычек должен как-то отде- ляться, чтобы избежать аварийного завершения строки. Это достига- ется путем добавления перед каждым символом кавычек управляющей последовательности (или управляющего оператора) \. Например, что- бы включить кавычки в строковую переменную, пишем следующее:
String quote = " \"Удача благоволит храбрым.\" сказал Вергилий ";
Для форматирования простейшего вывода можно использовать раз- личные управляющие последовательности:
Управляющий символ
Описание
\n
Перевод строки
\t
Табуляция
\b
Шаг назад (забой)
\r
Возврат каретки
\f
Перевод страницы
\\
Обратный слеш
\'
Одиночная кавычка (апостроф)
\"
Двойная кавычка
Управляющая последовательность для новой строки (\n) часто приме- няется для вывода нескольких строк. Аналогично, управляющая после- довательность табуляции (\t) используется для вывода содержимого в столбцах. Использование комбинаций новой строки и табуляции по- зволяет форматировать вывод как в строках, так и в столбцах — в виде некоторой таблицы.
Совет
В качестве альтернативы управляющей последова- тельности символов внутри двойных кавычек можно использовать одинарные кавычки.

41
Выполните следующие шаги для создания Java-программы, использую- щей управляющие последовательности для форматирования вывода.
1. Создайте новую программу с именем Escape, содержащую стан- дартный метод main.
class
Escape
{
public static void main( String[] args ) { }
}
2. Внутри фигурных скобок главного метода добавьте следующие строки кода для создания строковой переменной, содержащей форматированные названия таблицы и заголовки столбцов.
String header = "\n\tНЬЮ-ЙОРК ПРОГНОЗ НА 3 ДНЯ:\n" ;
header += "\n\tДень\t\tМакс\tМин\tОсадки\n" ;
header += "\t---\t\t----\t---\t----------\n" ;
3. Добавьте следующие строки для создания строковой переменной, содержащей форматированные данные и ячейки таблицы.
String forecast = "\tВоскресенье\t68F\t48F\tЯсно\n" ;
forecast += "\tПонедельник\t69F\t57F\tЯсно\n" ;
forecast += "\tВторник\t\t71F\t50F\tОблачность\n" ;
4. Добавьте строку для вывода обоих значений форматированных строк.
System.out.print( header + forecast ) ;
5. Сохраните программу под именем Escape.java, затем скомпилируй- те и запустите.
JAVA
Escape.java
На заметку
В данном случае управляю- щая последовательность добавляет символ новой строки, поэтому здесь ис- пользуется метод print(), а не println(), который добавляет символ новой строки после вывода.

2. Выполнение операций
42
Работа с битами
В дополнение к обычным операторам, описанным в этой главе, язык
Java предлагает специальные операторы для работы с бинарными зна- чениями. Они, конечно, используются, в отличие от обычных опера- торов, гораздо реже, но для общего знакомства приведем краткий их обзор.
«Побитовые» операторы в языке Java можно использовать с данными целочисленного типа для того, чтобы манипулировать битами дво- ичного значения. Для этого нужно понимать, как десятичные числа от 0 до 255 представляются в виде 8 бит.
Например, десятичное число 53 представляется двоичным 00110101
( 0×128,0×64,1×32,1×16,0×8,1×4,0×2,1×1 ).
Операции двоичного сложения выполняются подобно арифметиче- ским операциям над десятичными числами.
53
=
00110101
+
7
=
00000111
60
=
00111100
Кроме того, побитовые операторы предлагают специальные операции над двоичными числами.
Оператор
Операция
Пример
Результат
&
И
a & b
1, если оба бита 1
|
ИЛИ
a | b
1, если хотя бы один бит 1
1   2   3   4   5   6   7   8   9   ...   18


написать администратору сайта