Java: задачи по основам программирования е капель ф зэев

В этой главе рассматриваются основные синтаксисы языка программирования Java. Я предполагаю. Что вы написали несколько простых программ на Java. В противном случае прочтите Введение В Программирование На Java для начинающих Программистов Чтобы хорошо владеть языком программирования. Вам нужно овладеть двумя вещами:

  1. Синтаксис языка программирования: Не так уж сложно выучить небольшой набор ключевых слов и синтаксисов. Например, JDK 1.8 содержит 48 ключевых слов, C11-44, а C++11-73.
  2. Библиотеки прикладного программного интерфейса (API). Связанные с языком: Вы не хотите писать все с нуля сами.

    Вместо этого можно повторно использовать доступный код в библиотеке. Изучение библиотеки может быть сложным. Так как она действительно огромна. Развивается и может взять на себя роль другого языка программирования.

Первые несколько разделов немного скучноваты. Так как я должен объяснить основные понятия с некоторыми деталями.

Вы также можете попробовать Упражнения по основам Java

1.  Основные синтаксисы

1.1  Шаги по написанию программы Java

Шаги по написанию программы Java иллюстрируются следующим образом:

JavaBasics_Process.png

Шаг 1: Напишите исходный код Xxx.javaс помощью текстового редактора программирования (например. Sublime Text, Atom. Notepad++, Textpad. GEdit) или IDE (например. Eclipse или NetBeans).

Шаг 2: Скомпилируйте исходный код Xxx.javaв Java portable bytecode Xxx.classс помощью компилятора JDK. Выполнив команду:

javac Xxx.java 

Шаг 3: Запустите скомпилированный байтXxx.class-код с входными данными для получения желаемого результата. Используя среду выполнения Java. Выполнив команду:

java Xxx 

1.2  Шаблон программы Java

Вы можете использовать следующий шаблон для написания своих Java-программ. Выберите значимое Имя классацель вашей программы. И запишите свои программные операторы внутри тела main()метода. Теперь не беспокойтесь о других терминах и ключевых словах. Я объясню их в свое время. Оставляйте комментарии в своей программе!

1 2 3 4 5 6 7 8
 public class Classname { public static void main(String[] args) { // Ваши программные операторы здесь!!!

1.3  Пример программы. Иллюстрирующей Последовательные. Решающие и Циклические конструкции

Ниже приведена простая программа Java . Которая демонстрирует три основных конструкта программирования: последовательный, циклическийи условный. Прочитайте Введение в программирование Java для начинающих программистов

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
 public class OddEvenSum { public static void main(String[] args) { final int LOWERBOUND = 1; final int UPPERBOUND = 1000; int sumOdd = 0; int sumEven = 0; int absDiff; int number = LOWERBOUND; while (number 

Ожидаемыми результатами являются:

Сумма нечетных чисел от 1 до 1000 равна: 250000
Сумма четных чисел от 1 до 1000 равна: 250500
Абсолютная разница между двумя суммами равна: 500

1.4  Комментарии

Комментарии используются для документирования и объяснения кода и логики программы. Комментарии-это не операторы программирования. Они игнорируются компилятором и не имеют последствий для выполнения программы. Тем не менее. Комментарии ОЧЕНЬ ВАЖНЫ для предоставления документации и объяснений для других. Чтобы понять ваши программы (а также для вас самих через три дня).

Есть два вида комментариев в Java:

  1. Многострочный комментарий: начинается с буквы а /*и заканчивается буквой а */и может охватывать несколько строк. /** .... */ это специальный комментарий к документации. Эти комментарии могут быть извлечены для создания документации.
  2. Конец строки (Однострочный) Комментарий: начинается с //конца текущей строки и продолжается до конца текущей строки.

Я рекомендую вам свободно использовать комментарии для объяснения и документирования вашего кода.

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

1.5  Операторы и блоки

Оператор: Оператор программирования является наименьшей независимой единицей в программе, так же. Как предложение в английском языке. Он выполняет часть действия программирования. Оператор программирования должен заканчиваться точкой с запятой (;), так же. Как английское предложение заканчивается точкой. (Почему не заканчивается точкой. Как английское предложение? Это происходит потому. Что период падает с десятичной запятой — это сложно для немого компьютера. Чтобы различить период и десятичную точку в первые дни вычислений!)

Для примера,

 int number1 = 10; int number2, number3 = 99; инт продукт; число 2 = 8; продукт = number1 * number2 * number3; System.out.println(

Блок: Блок-это группа программных операторов. Окруженных парой фигурных скобок { }. Все операторы внутри блока рассматриваются как единое целое. Блоки используются в качестве тела в конструкциях типа class, method. If-else и loop. Которые могут содержать несколько операторов. Но обрабатываются как одна единица (одно тело). Нет необходимости ставить точку с запятой после закрывающей скобки. Чтобы закончить составной оператор. Пустой блок (т. е. Нет оператора внутри фигурных скобок) не допускается.

Для примера,

 System.out.println(System.out.println(if (input != -1) { System.out.println(} еще { i = 1; в то время как (я) { System.out.print(i + public static void main(String[] args) { ..заявления...public class Hello { ..заявления...

1.6 Пробелы и Форматирование Исходного кода

Пробелы: Пробел, табуляция и новая строка совместно называются пробелами.

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

int sum = 0; double average; 

Java, как и большинство языков программирования. Игнорирует лишние пробелы. То есть несколько смежных пробелов рассматриваются как одно пустое пространство. Дополнительные пробелы и дополнительные строки игнорируются, например,

 int sum =0 ; двойное среднее ; int sum=0;двойное среднее;

Форматирование исходного кода: Как уже упоминалось. Дополнительные пробелы игнорируются и не имеют никакого вычислительного значения. Однако правильный отступ (с табуляциями и пробелами) и дополнительные пустые строки значительно улучшают читабельность программы. Это чрезвычайно важно для других (и для вас самих через три дня). Чтобы понять ваши программы.

Например, работает следующая однострочная программа hello-world. Но можете ли вы прочитать и понять программу?


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

Отступ: Отступ каждого уровня тела блока на дополнительные 3 или 4 пробела в соответствии с иерархией блока. Не используйте tab. Потому что tab-spaces зависит от редактора.

 public class className { public static void main(String[] args) { statement-1; заявление-2; if (тест) { истинные утверждения; } еще { ложные утверждения Инициализация оператора цикла; while (тест) { тело-заявления; обновление} 

Следовательно. Вы должны убедиться. Что ваш код читается (другими и самим собой через 3 дня). Следуя условностям и рекомендуемому стилю кодирования.

2. Переменные и типы

2.1 Переменные — Имя. Тип и Значение

Компьютерные программы манипулируют (или обрабатывают) данными. Переменная используется для хранения части данных для обработки. Он называется переменным, потому что вы можете изменить сохраненное значение.

Точнее, переменная-это именованное место хранения. В котором хранится значение определенного типа данных. Другими словами, переменная имеет имя, тип и хранит значение.

На следующей диаграмме показаны три типа переменных: int, doubleи String. intПеременная хранит целое число (или целое число. Или число с фиксированной точкойdouble); переменная хранит число с плавающей точкой (или действительное число); Stringпеременная хранит тексты.

переменная

2.2 Идентификаторы (или Имена)

Идентификатор необходим для именования переменной (или любой другой сущности. Такой как метод или класс). Java налагает на идентификаторы следующие правила:

  • Идентификатор-это последовательность символов любой длины, состоящая из прописных и строчных букв(a-z. A-Z), цифр (0-9), подчеркивания (_) и знака доллара ($).
  • Пробелы (пробел, табуляция, новая строка) и другие специальные символы (такие как +, -, *, /, @, &, запятые и т. Д.) Не допускаются. Обратите внимание. Что пробел и тире (-) недопустимы. То есть max valuemax-value(Это потому. Что blank создает два токена. А dash вылетает со знаком минус!)
  • Идентификатор должен начинаться с буквы (a-z. A-Z)или символа подчеркивания (_). Она не может начинаться с цифры (0-9)(потому что ее можно спутать с цифрой). Идентификаторы. Начинающиеся со знака доллара ($), зарезервированы для системных сущностей.
  • Идентификатор не может быть зарезервированным ключевым словом или зарезервированным литералом (напр., class, int, double, if, else, for, true, false, null).
  • Идентификаторы чувствительны к регистру. roseRoseROSE

Примеры: abc, _xyz, $123, _1_2_3являются допустимыми идентификаторами. Но 1abc, min-value, surface area, ab@cне являются допустимыми идентификаторами.

Внимание: Программисты не используют пустой символ ни в каких именах (имя файла. Имя проекта. Имя переменной и т. Д.). Он либо не поддерживается (например. В Java и C/C++). Либо создаст вам гораздо больше проблем.

Соглашение об Именовании Переменных

Имя переменной-это существительное или именная фраза. Состоящая из нескольких слов без пробелов между словами. Первое слово находится в нижнем регистре. А остальные слова-с заглавной буквы. Например,radius,area,fontSize,numStudents,,xMax,yMin, xTopLeft,isValidInput, и thisIsAVeryLongVariableName. Эта конвенция также известна как верблюжий случай.

Рекомендации
  1. Важно выбрать имя. Которое является самоописательным и точно отражает значение переменной, например , numberOfStudentsилиnumStudents, но не nили x, хранить количество студентов. Можно использовать аббревиатуры.
  2. Не используйте бессмысленные имена. Такие как a, b, c, i, j, k, n, i1, i2, i3, j99, exercise85(какова цель этого упражнения?), и example12(О чем этот пример?).
  3. Избегайте однобуквенных имен. Таких какi,j,k,a,b,c, которые легче печатать. Но часто бессмысленны. Исключение составляют общие имена. Такие какx,y, zдля координат, iдля индекса. Длинные имена труднее печатать. Но вы сами задокументируете свою программу. (Я предлагаю вам иногда практиковаться в печатании.)
  4. Используйте существительные единственного и множественного числа с осторожностью. Чтобы различать переменные единственного и множественного числа. Например, вы можете использовать переменную rowдля ссылки на один номер строки и переменную rowsдля ссылки на множество строк (например. Массив строк — будет обсуждаться позже).

2.3 Объявление переменной

Чтобы использовать переменную в вашей программе. Вам нужно сначала ввести ее , объявив ее имя и типв одном из следующих синтаксисов. Акт объявления переменной выделяет хранилище размера. Способное удерживать значение типа.

Синтаксис Пример
 типа идентификатор типа; 
int sum; двойное среднее; Строка StatusMsg;
 типа identifier1, identifier2, ..., identifierN; 
int число, количество; двойная сумма, разница. Произведение, частное; Строка helloMsg. GameOverMsg;
 идентификатор типа начального значения = initialValue; 
int MagicNumber = 99; двойной пи = 3,14169265; Строка helloMsg = 
 type identifier1 = initValue1, ..., identifierN = initValueN; 
int sum = 0, product = 1; двойная высота = 1,2; длина = 3,45; Строка greetingMsg = 

Примите к сведению, что:

  • Переменная объявляется с типом. Как только тип переменной объявлен. Она может хранить только значение. Принадлежащее этому конкретному типу. Например, intпеременная может содержать только целое число (например,123), а НЕ число с плавающей запятой (например,-2.17) или текстовую строку (например,"Hello").
  • Каждая переменная может быть объявлена только один раз. Поскольку идентификатор должен быть уникальным.
  • Вы можете объявить переменную в любом месте программы. Если она объявлена перед использованием.
  • Тип переменной не может быть изменен внутри программы. Как только она объявлена.
  • Оператор объявления переменной начинается с типаи работает только для этого типа. Другими словами. Вы не можете объявить переменные двух разных типов в одном операторе объявления.
  • Java является статически типизированным языком. Это означает. Что тип решается во время компиляции и никогда не изменяется.

2.4 Константы (конечные переменные)

Константы-это немодифицируемые (неизменяемые) переменные. Объявленные с помощью ключевого finalслова . Конечным переменным можно назначить значения только ОДИН РАЗ. Их значения нельзя изменить во время выполнения программы. Для примера:

final double PI = 3.14159265; final int SCREEN_X_MAX = 1280; SCREEN_X_MAX = 800; final int SCREEN_Y_MIN; SCREEN_Y_MIN = 0; SCREEN_Y_MIN = 10; ошибка компиляции: переменная может быть уже назначена

Постоянное соглашение об именовании: Используйте заглавные слова. Соединенные подчеркиванием. Например, MIN_VALUE, MAX_SIZE, и INTEREST_RATE_6_MTH.

2.5 Выражения

Выражение представляет собой комбинацию операторов (таких как '+'и '-') и операндов (переменных или литералов). Которые могут быть вычислены для получения одного значения определенного типа.

выражение

Например,

 ((1 + 2) * 3 / 4) % 6 3.45 + 6.7 sum + number * number principal * (1.0 + InterestRate) 

2.6 Назначение (=)

Оператор присваивания вычисляет RHS (Правая часть) и присваивает результирующее значение переменной LHS (левая часть).

Синтаксис оператора присваивания таков:

Синтаксис Пример
 переменной LHS variable = literalValue;
int число; число = 9;
 variable = expression;
int sum = 0, number = 8; sum = сумма + число;

Оператор присваивания должен интерпретироваться следующим образом: выражение на RHS сначала вычисляется для получения результирующего значения (называемого r-value или right-value). Затем значение r присваивается переменной на левой стороне (LHS) или l-значению. Обратите внимание. Что вы должны сначала оценить RHS. Прежде чем присвоить результирующее значение LHS. Для примера,

int число; number = 8; number = number + 1; 8 = number; number + 1 = sum; 
‘=’ — это Присвоение. А НЕ Равенство

x_plus_one.gif

В Java равный символ '='известен как оператор присваивания. Смысл '='в программировании отличается от математики. Он обозначает присвоение значения RHS переменной LHS, а НЕ равенство RHS и LHS. RHS должен быть литеральным значением или выражением. Которое приводит к значению; в то время как LHS должна быть переменной.

Обратите внимание. Что x = x + 1это допустимо (и часто используется) в программировании. Он вычисляет выражение RHS x + 1и присваивает результирующее значение переменной LHS x. С другой стороны, x = x + 1это незаконно в математике.

Хотя x + y = 1это разрешено в математике. Это недопустимо в программировании. Потому что LHS оператора присваивания должен быть переменной.

Некоторые языки программирования используют символ :=->

3. Примитивные типы и строка

В Java существует две широкие категории типов данных:

  1. Примитивные типы (например, int, double),
  2. Ссылочные типы (например. Объекты и массивы).

Здесь мы опишем примитивные типы. Мы рассмотрим ссылочные типы (классы и объекты) в последующих главах

3.1 Встроенные типы примитивов

ТИП ОПИСАНИЕ
байт Целое число 8-разрядное целое
число со знаком Диапазон [-27, 27-1] = [-128, 127]
короткий 16-битное целое
число со знаком Диапазон [-215, 215-1] = [-32768, 32767]
инт 32-разрядное целое
число со знаком Диапазон [-231, 231-1] = [-2147483648, 2147483647](≈9 цифр, ±2G)
длинный 64-разрядное целое
число со знаком Диапазон [-263, 263-1] = [-9223372036854775808, 9223372036854775807](≈19 цифр)
плыть
Число с плавающей запятой

F x 2E
32-разрядное одинарное прецизионное число с плавающей запятой
(6-7 значащих десятичных цифр, в диапазоне±[1.4x10-45, 3.4028235x1038])
двойной 64-битное число с плавающей запятой двойной точности
(14-15 значащих десятичных разрядов, в диапазоне±[4.9x10-324, 1.7976931348623157x10308])
обуглить Символ
, представленный в 16-битном Unicode '\u0000'to'\uFFFF'.
, может рассматриваться как целое число в диапазоне [0, 65535]арифметических операций.
(В отличие от C/C++. Который использует 8-битный код ASCII.)
логический Двоичный
файл Принимает литеральное значение либо trueили false.
Размер booleanне определен в спецификации Java. Но требует по крайней мере одного бита.
booleans используются в тесте в решении и цикле. Не применимых для арифметических операций.
(В отличие от C/C++. Который использует целое 0число для false и ненулевое значение для true.)

примитивные типы

Примитивные типы встроены в язык для максимальной эффективности. Как с точки зрения пространства. Так и вычислительной эффективности.

Java имеет восемь примитивных типов, как указано в приведенной выше таблице:

  • Существует четыре целочисленных типа: 8-битный byte, 16-битный short, 32-битный intи 64-битный long. Они являются целыми числами со знаком в дополнительном представлении 2и могут содержать нулевое . Положительное и отрицательное целочисленное значение различных диапазонов. Как показано в таблице.
  • Существует два типа с плавающей запятой: 32-битная одинарная точность floatи 64-битная двойная точность double. Они представлены в научной нотации Fx2Eтого места. Где дробь (F) и показатель степени (E) хранятся отдельно (как указано стандартом IEEE 754). Обратите внимание. Что не все действительные числа могут быть представлены через floatи double. Это происходит потому . Что существуют бесконечные вещественные числа даже в небольшом диапазоне значений[1.0, 1.1], но существует конечное число паттернов в n-битном представлении. Большинство значений с плавающей запятой приближены к их ближайшему представлению.
  • Тип charпредставляет один символ. Например'0','A','a'. В Java charон представлен с использованием 16-битного Юникода (в формате UCS-2) для поддержки интернационализации (i18n). A charможно рассматривать как целое число в диапазоне [0, 65535]арифметических операций in. Например, символ '0'48(десятичный) или 30H(шестнадцатеричный); символ 'A'65(десятичный) или 41H(шестнадцатеричный); символ 'a'97(десятичный) или 61H(шестнадцатеричный).
  • Java вводит новый двоичный тип под названием booleantrueили false. booleans используются в тесте в решении и цикле. Они не применимы к арифметическим операциям (таким как сложение и умножение).

3.2 Целые числа против Числа с плавающей запятой

В компьютерном программировании целые числа (например, 123, -456) и числа с плавающей запятой (например, 1.23, -4.56, 1.2e3, -4.5 e-6) СОВЕРШЕННО разные.

  1. Целые числа и числа с плавающей запятой представляются и хранятся по-разному.
  2. Целые числа и числа с плавающей запятой работают по-разному.
Как представляются и хранятся в памяти компьютера целые числа и числа с плавающей запятой?

DataRep_Integers.png

Целые числа представлены в так называемой схеме дополнения 2, как показано на рисунке. Наиболее значимый бит называется Знаковым битом (S), где S=0он представляет положительное целое число и S=1представляет отрицательное целое число. Остальные биты представляют собой величину целых чисел. Для целых положительных чисел величина равна двоичному числу, например if n=16(short), 0000000000000010is +210. Отрицательные целые числа требуют преобразования дополнения 2.

DataRep_Integers.png

Числа с плавающей запятой представляются в научной форме Fx2E, где Дробь (F) и Показатель степени (E) хранятся отдельно. Например, хранить 12.7510; сначала преобразовать в двоичный код of 1100.112; затем нормализовать до 1.100112 x 23; у нас есть F=1.1011и E=310=112которые затем хранятся с некоторым масштабированием.

Подробнее читайте в разделе Представление данных — Целые числа. Числа с плавающей запятой и символы

Как работают целые числа и числа с плавающей запятой?

Целые числа и числа с плавающей запятой управляются по-разному. Используя различные аппаратные схемы. Целые числа обрабатываются в CPU (Центральный процессор). А числа с плавающей запятой-в FPU (сопроцессор с плавающей запятой).

Целочисленные операции выполняются прямолинейно. Например, целочисленное сложение выполняется так. Как показано на рисунке:

Сложение Целых чисел

С другой стороны. Сложение с плавающей точкой является сложным. Как показано на рисунке:

Добавление плавающей точки

Очевидно. Что целочисленные операции (такие как сложение) намного быстрее операций с плавающей запятой.

Кроме того, целые числа точны. Все числа в пределах диапазона могут быть представлены точно. Например, 32-бит intможет представлять ВСЕ целые числа от -2147483648до +2147483647без промежутка между ними. С другой стороны. Плавающие точки-это НЕ точное. А близкое приближение. Это связано с тем. Что в любом интервале (например. От 0,1 до 0,2) существуют бесконечные числа с плавающей запятой. Не ВСЕ числа могут быть представлены с конечной точностью (32-битные floatили 64-битные double).

Вы должны рассматривать целые числа и числа с плавающей запятой как два РАЗЛИЧНЫХ типа в программировании!
Используйте целое число. Если это возможно (оно быстрее. Точнее и использует меньше битов). Используйте число с плавающей запятой только в том случае. Если требуется дробная часть.

3.3 Представление данных

Прочтите Представление данных — Целые числа. Числа с плавающей запятой и символы

Короче говоря, важно обратить внимание на то, что char '1'отличается отint 1,byte 1,short 1,float 1.0,double 1.0, и String "1". Они по-разному представлены в памяти компьютера. С разной точностью и интерпретацией. Они также обрабатываются по-разному. Для примера:

  • byte 1 is "00000001"(8-бит).
  • short 1 is "00000000 00000001"(16-бит).
  • int 1 is "00000000 00000000 00000000 00000001"(32-бит).
  • long 1 is "00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001"(64-бит).
  • float 1.0 is "0 01111111 0000000 00000000 00000000"(32-бит).
  • double 1.0 is "0 01111111111 0000 00000000 00000000 00000000 00000000 00000000 00000000"(64-бит).
  • char '1' is "00000000 00110001"(16-бит) (Unicode number 49).
  • String "1" это сложный объект (много-много битов).

Существует тонкая разница между int 0ними, double 0.0поскольку они имеют разную длину битов и внутренние представления.

Кроме того, вы ДОЛЖНЫ знать тип значения. Прежде чем сможете интерпретировать значение. Например, этот битовый шаблон "00000000 00000000 00000000 00000001"не может быть интерпретирован. Если вы не знаете его тип (или его представление).

3.4 Максимальные/Минимальные значения типов примитивных чисел

Следующая программа может быть использована для печати максимальной, минимальной и битовой длины примитивных типов. Например, максимальный. Минимальный и битовый размер intхранятся во встроенных константахINTEGER.MIN_VALUE,INTEGER.MAX_VALUE,INTEGER.SIZE.

 public class PrimitiveTypesMinMaxBitLen { public static void main(String[] args) { System.out.println(MIN_VALUE); System.out.println(MAX_VALUE); System.out.println(РАЗМЕР); System.out.println(MIN_VALUE); System.out.println( System.out.println( System.out.println(MIN_VALUE); System.out.println(MAX_VALUE); System.out.println(РАЗМЕР); System.out.println(MIN_VALUE); System.out.println( System.out.println( System.out.println(MIN_VALUE); System.out.println(MAX_VALUE); System.out.println(РАЗМЕР); System.out.println(MIN_VALUE); System.out.println( System.out.println(РАЗМЕР); System.out.println(MIN_VALUE); System.out.println(MAX_VALUE); System.out.println(РАЗМЕР); 

3.5 Еще Один Важный Тип — Строка

Помимо 8 примитивных типов. Есть еще один важный и часто используемый тип String. A String— это последовательность символов (текстов). Таких как "Hello, world". String не является примитивным типом (это будет рассмотрено позже).

В Java achar-это один символ. Заключенный в одинарные кавычки (например,'A','0','$'); в то время как aString-это последовательность символов. Заключенная в двойные кавычки (например,"Hello").

Например,

String greetingMsg = char gender = 'm'; String StatusMsg = 

3.6 Выбор типов данных для переменных

Как программист. Вы должны решить. Какой тип переменных будет использоваться в ваших программах. В большинстве случаев решение принимается интуитивно. Например, используйте целочисленный тип для подсчета и целого числа; тип с плавающей запятой для числа с дробной частью, Stringдля текстового сообщения, charдля одного символа и booleanдля двоичных результатов.

Важно отметить. Что ваши программы будут иметь данные РАЗНЫХ типов.

Эмпирические правила выбора типов данных
  • Для чисел используйте целочисленный тип. Если это возможно. Используйте тип с плавающей запятой. Только если число содержит дробную часть. Хотя числа с плавающей запятой включают целые числа (например,1.0,2.0,3.0,), числа с плавающей запятой являются приближенными (не точными) и требуют больше ресурсов (вычислительных и запоминающих) для операций.
  • Хотя есть 4 целочисленных типа: 8-битный byte, 16-битный short, 32-битный intи 64-битный long, мы будем использовать intдля целых чисел в целом. Используйте byte, short, и longтолько если у вас есть веская причина выбрать именно эту точность.
  • Среди них есть два типа с плавающей запятой: 32-битный floatи 64-битный double, которые мы будем использовать doubleв целом. Используйте floatтолько в том случае. Если вы хотите сохранить память и не нуждаетесь в точности double.
  • char, booleanи Stringимеют свое специфическое использование.

Пример (Имена переменных и типы): Пол купил новый ноутбук марки Он выбрал план обслуживания Определите типы данных и назовите переменные.

Возможные имена и типы переменных:

Имя строки = String brand = double processorSpeedInGHz = 2.66; double ramSizeInGB = 8; int harddiskSizeInGB = 500; int monitorinch = 15; двойная цена = 1760,55; char servicePlan = 'C'; логический onSiteService = true; булево extendedWarranty = false;

Упражнение (Имена и типы переменных): Вас просят разработать программное обеспечение для колледжа. Система должна поддерживать информацию о студентах. Сюда входят имя, адрес. Номер телефона, пол. Дата рождения, рост, вес. Преследуемая ученая степень (например. B.Sc, Бакалавр). Год обучения. Средний средний балл. С/без стипендии на обучение. Является/не является стипендиатом. Каждому студенту присваивается уникальный 8-значный номер в качестве идентификатора.
От вас требуется идентифицировать переменные. Присвоить каждой из них подходящее имя и выбрать подходящий тип. Запишите операторы объявления переменных. Как в приведенном выше примере.

3.7 Литералы для примитивных типов и строк

Литералили литеральная константа-это конкретное постоянное значение, например123-456, 3.1416,-1.2E3,4.5e-6,'a',"Hello", которое используется в исходном коде программы. Он может быть присвоен непосредственно переменной или использоваться как часть выражения. Их называют литералами, потому что они буквально и явно идентифицируют свои значения. Мы называем его буквальным, чтобы отличить его от переменной.

Целочисленные (int, длинные, короткие, байтовые) литералы

Литерал целого числа, такой как 123and -456, intпо умолчанию рассматривается как an. Например,

int number = -123; инт сумма = 1234567890; инт bigSum = 8234567890; и int intRate = 6%; инт платить = $1234; инт продукта = 1,234,567; 

intЛитералу может предшествовать знак плюс (+) или минус (-), за которым следуют цифры. Никакие запятые или специальные символы (например, $, %, или пробел) не допускаются (например, 1,234,567, $123и 12%являются недопустимыми).

Вы можете использовать префикс '0'(ноль) для обозначения целочисленного литерального значения в восьмеричной системе счисления и префикс '0x'(или '0X') для значения в шестнадцатеричной системе счисления, например,

int number1 = 1234; int number2 = 01234; int number3 = 0017; int number4 = 0x1abc; 

В JDK 7 можно использовать префикс0b‘ или0B‘ для указания целочисленного литерального значения в двоичном формате. Вы также можете использовать подчеркивание (_), чтобы разбить цифры на группы для улучшения читаемости. Но вы должны начинать и заканчивать литерал цифрой. А не подчеркиванием. Например,

 int number1 = 0b0101000010100010101000010100010; int number2 = 0b0101_0000_1010_0010_1101_0000_1010_0010; int number3 = 2_123_456; int number4 = _123_456; 

longЛитерал вне intдиапазона требует суффикса 'L'или 'l'(избегайте нижнего регистра 'l', который можно перепутать с номером один '1'), например,123456789012L,-9876543210l. Например,

long sum = 123; long bigSum = 1234567890123L; 

Для byteлитералов и не требуется никакого суффиксаshort. Но вы можете использовать значения только в разрешенном диапазоне. Например,

byte smallNumber1 = 123; byte smallNumber2 = -1234; short midSizeNumber1 = -12345; short midSizeNumber2 = 123456; 
Литералы с плавающей точкой (double, float)

Литеральное число с десятичной точкой, такое как 55.66и -33.44, doubleпо умолчанию рассматривается как а. Вы также можете выразить их в научной нотации, например, 1.2e3, -5.5E-6, где eили Eобозначает показатель степени в основании 10. Перед дробной частью или показателем степени можно поставить знак плюс (+) или минус (-). Значения экспоненты ограничены целым числом. В номере не должно быть пробелов или других символов.

Вам напоминают . Что числа с плавающей запятой хранятся в научной формеFx2E, где F(Дробь) и E(Показатель степени) хранятся отдельно.

Вы можете дополнительно использовать суффикс 'd'или 'D'для обозначения doubleлитералов.

Вы ДОЛЖНЫ использовать суффикс 'f'или 'F'для floatлитералов. Например,-1.2345F. Например,

float average = 55.66; float average = 55.66 F; float rate = 1.2 e-3; float rate = 1.2 e-3f; 
Характер (char) Литералы и Escape-последовательности

Печатаемый charлитерал (например, буквы . Цифры и специальные символы) пишется. Заключая символ в пару одинарных кавычек, например,'A','z', '0', '9','$', и '@'. Специальные charлитералы (такие как tab. Newline) представляются с помощью так называемых escape-последовательностей (которые будут описаны ниже).

В Java chars представлены с помощью 16-битного Unicode. Печатные символы для английских букв (a-z, A-Z), цифр (0-9) и символов (+, -, @, и т.д.) присваиваются кодовым номерам 32-126 (20H-7EH). Как показано в таблице ниже (расположены в десятичной и шестнадцатеричной системах счисления).

Дек 0 1 2 3 4 5 6 7 8 9
3     SP ! « # $ % &
4 ( ) * + , . / 0 1
5 2 3 4 5 6 7 8 9 : ;
6 = > ? @ Один Б С Д E
7 Ф Г Х Я Дж К Л М Н O
8 П Q Р С Т U В W Икс Y
9 Зет [ \ ] ^ _ ` один б с
10 д e ф г х я j к л м
11 н o п q Р с т u в w
12 икс y зет { | } ~      
Шестиугольный 0 1 2 3 4 5 6 7 8 9 Один Б С Д E Ф
2 SP ! « # $ % & ( ) * + , . /
3 0 1 2 3 4 5 6 7 8 9 : ; = > ?
4 @ Один Б С Д E Ф Г Х Я Дж К Л М Н O
5 П Q Р С Т U В W Икс Y Зет [ \ ] ^ _
6 ` один б с д e ф г х я j к л м н o
7 п q Р с т u в w икс y зет { | } ~  

В Java a charможно рассматривать как его базовое целое число в диапазоне [0, 65535]in арифметических операций. Другими словами, charи целое число взаимозаменяемы в арифметических операциях. Вы можете рассматривать a charкак int,вы также можете назначить целое значение в диапазоне [0, 65535]charпеременной. Например,

char letter = 'a'; char anotherLetter = 98; System.out.println(letter); System.out.println(anotherLetter); anotherLetter += 2; System.out.println(anotherLetter); 

Специальные символы представлены так называемой escape-последовательностью, которая начинается с обратной косой черты (\), за которой следует шаблон. Например, \tдля tab, \nдля newline. Обычно используемые escape-последовательности:

Escape
-последовательность
Описание Unicode
(Десятичный)
Unicode
(Hex)
\t Табуляция 9 0009Ч
\n Newline (или Line-feed) 10 000АХ
\r Возврат каретки 13 000DH
Двойная кавычка (необходимо использовать внутри двойной кавычкиString)
\’ Одинарная кавычка (должна использоваться внутри одинарной кавычки char, т. е.'\'')
\\ Back-slash (Требуется как back-slash придается особое значение)
хм Номер Unicode hhhh (в шестнадцатеричном формате). Например, is 您, is 好 hhhhh

Для примера,

char tabChar = '\t'; char anotherTabChar = 9; char newlineChar = '\n'; char backSlashChar = '\\'; char singleQuoteChar = '\ char doubleQuoteChar = ' System.out.println(
Строковые литералы и Escape-последовательности

АString-это последовательность символов. StringЛитерал состоит из нуля или более символов. Окруженных парой двойных кавычек. Для примера,

String directionMsg = Строка greetingMsg = String StatusMsg = 

Вам нужно использовать escape-последовательность для специальных непечатаемых символов. Таких как newline (\n) и tab (\t). Вам также необходимо использовать escape-последовательность для двойных кавычек (\") и обратной косой черты (\\) из-за конфликта. Для примера,

Строка str1 = \tworld\n String str2 = \hello\Строка str3 = \\, еще 2 back-slash \\\\String str1 = \string\ nested \\inside\\ a string Строка str2 = \u60a8\u597d!

Одинарная кавычка (') внутри a Stringне требует escape-последовательности. Поскольку нет никакой двусмысленности, например,

String str3 = 

Важно отметить. Что \tили\"-это ОДИН символ, А НЕ ДВА!

Упражнение: Напишите программу для печати следующего изображения животного с помощью System.out.println(). Обратите внимание. Что вам нужно использовать escape-последовательности для печати некоторых символов, например, \"for ", \\for \.

 '__' (оо) +========\/ / || %%% || * ||-----|| 
Конец линии (EOL)

Newline (0AH) и Carriage-Return (0DH), представленные escape-последовательностью \n, \rсоответственно используются в качестве разделителя строк (или end-of-line, или EOL) для текстовых файлов. Обратите внимание. Что Unix и macOS используют \nфункцию (0AH) в качестве EOL. В то время как Windows использует \r\nфункцию (0D0AH).

логические литералы

Есть только два booleanлитерала. Т. е.truefalse Например,

boolean done = true; boolean GameOver = false; логический isValid; isValid = false;
Пример по литералам
 публичный класс LiteralTest { public static void main(String[] args) { String name = char gender = 'm'; boolean isMarried = true; byte numChildren = 8; short yearOfBirth = 1945; int salary = 88000; длинный netAsset = 8234567890L; двойной вес = 88,88; float gpa = 3.88 f; System.out.println(Имя: Tan Ah Teck System.out.println( System.out.println( System.out.println( System.out.println( System.out.println( System.out.println( System.out.println( System.out.println(

3.8 var — Вывод типа локальной переменной (JDK 10)

JDK 10 вводит новый способ объявления переменных с помощью нового ключевого varслова , например,

var v1 = 0; var v2 = 0.0; var v3 = 1.0 f; var v4 = '0'; var v5 = var v6; ошибка компиляции: невозможно использовать 'var' для переменной без инициализатора

Очевидно. Что вам нужно инициализировать переменную. Чтобы компилятор мог определить ее тип.

4. Основные Операции

4.1 Арифметические операторы

Java поддерживает следующие двоичные/унарные арифметические операции:

Оператор Режим Использование Описание Примеры
+ Двоичный
Унарный
x + y
+x
Сложение
Унарное положительное
1 + 2 ⇒ 3
1.1 + 2.2 ⇒ 3.3
Двоичный
Унарный
x - y
-x
Вычитание
Унарное отрицание
1 — 2 ⇒ -1
1.1 — 2.2 ⇒ -1.1
* Двоичный x * y Умножение 2 * 3 ⇒ 6
3.3 * 1.0 ⇒ 3.3
/ Двоичный x / y Деление 1 / 2 ⇒ 0
1.0 / 2.0 ⇒ 0.5
% Двоичный x % y Модуль (Остаток) 5 % 2 ⇒ 1
-5 % 2 ⇒ -1
5.5 % 2.2 ⇒ 1.1

Эти операторы обычно являются двоичными операторами инфикса, т. Е. Они Берут два операнда с оператором между операндами (например, 11 + 12). Однако '-'и '+'может также интерпретироваться как унарный префиксный оператор , с оператором перед операндом. Для примера,

int number = -9; number = -number; 

4.2 Арифметические Выражения

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

JavaBasics_ArithmeticExpression.png

должно быть написано как (1+2*a)/3 + (4*(b+c)*(5-d-e))/f - 6*(7/g+h). Вы не можете пропустить знак умножения (*), как в математике.

Правила о приоритете

Как Математика:

  1. Скобки ()имеют наивысший приоритет и могут использоваться для изменения порядка вычисления.
  2. Унарные '-'(отрицание) и '+'(положительное) имеют следующий более высокий приоритет.
  3. Умножение (*), деление (/) и модуль (%) имеют одинаковый приоритет. Они имеют приоритет над сложением (+) и вычитанием (-). Например, 1+2*3-4/5+6%7интерпретируется как 1+(2*3)-(4/5)+(6%7).
  4. В пределах одного и того же уровня приоритета (то есть сложения/вычитания и умножения/деления/модуля) выражение вычисляется слева направо (так называемое левоассоциативное). Например, 1+2-3+4оценивается как ((1+2)-3)+4и 1*2%3/4есть ((1*2)%3)/4.

4.3 Преобразование типов в арифметических операциях

Ваша программа обычно содержит данные многих типов, например, countи sumare int, averageи gpaare double, и messageis a String. Поэтому очень важно понимать. Как Java обрабатывает типы в ваших программах.

Арифметические операторы (+,-, *,/,%) применимы только к примитивным типам чисел: byte, short,int, long,floatdouble, и char. boolean

Однотипные операнды int, long, float, double

Если ОБА операнда равны int, long, floatили double, то двоичные арифметические операции переносятся в этот тип и вычисляются до значения этого типа, т. е.,

  • int ⊕ int ⇒ int, где обозначает двоичные арифметические операторы типа+,-,*,/,%.
  • long ⊕ long ⇒ long
  • float ⊕ float ⇒ float
  • double ⊕ double ⇒ double
int Division

Важно отметить int, что деление производит anint, то int / int ⇒ intесть , с усеченным результатом. Например, 1/2 ⇒ 0(int), но 1.0/2.0 ⇒ 0.5(double / double ⇒ double).

Однотипные операнды byte, short, char: Преобразование в int

Если ОБА операнда являются byteshortили char, то двоичные операции выполняются в intи вычисляются до значения int. A charрассматривается как целое число его базового номера Unicode в диапазоне [0, 65535]. То есть,

  • byte ⊕ byte ⇒ int ⊕ int ⇒ int, где обозначает двоичные арифметические операторы. Такие как+,-,*,/,%.
  • short ⊕ short ⇒ int ⊕ int ⇒ int
  • char ⊕ char ⇒ int ⊕ int ⇒ int

Обратите внимание . Что НИКАКИЕ арифметические операции не выполняются в byteshortили char.

Для примера,

байт b1 = 5, b2 = 9, b3; b3 = b1 + b2; b3 = (byte)(b1 + b2); 

Однако если используются составные арифметические операторы (+=,-=,*=,/=,%=) (которые будут обсуждаться позже). Результат автоматически преобразуется в LHS. Например,

байт b1 = 5, b2 = 9; b2 += b1; 
Арифметические операции смешанного типа

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

  • byte, shortили charсначала повышается до intзначения перед сравнением с типом другого операнда. (В Java никакие операции in byteи shortor не выполняются char.)
  • Порядок продвижения по службе таков: int ⇒ long ⇒ float ⇒ double.

Для примера,

  1. int / double ⇒ double / double ⇒ double Отсюда, 1/2 ⇒ 0, 1.0/2.0 ⇒ 0.5, 1.0/2 ⇒ 0.5, 1/2.0 ⇒ 0.5
  2. 9 / 5 * 20.1 ⇒ (9 / 5) * 20.1 ⇒ 1 * 20.1 ⇒ 1.0 * 20.1 ⇒ 20.1 (Вы, вероятно. Не ожидаете такого ответа!)
  3. char '0' + int 2 ⇒ int 48 + int 2 ⇒ int 50 (Результат-это an int, char '2'который при желании нужно явно отбросить назад.)
  4. char ⊕ float ⇒ int ⊕ float ⇒ float ⊕ float ⇒ float
  5. byte ⊕ double ⇒ int ⊕ double ⇒ double ⊕ double ⇒ double
Резюме: Правила преобразования типов для двоичных операций

Правила продвижения типов для бинарных операций можно резюмировать следующим образом:

  1. Если один из операндов есть double, то другой операнд повышается доdouble;
  2. в противном случае . Если один из операндов естьfloat, то другой операнд повышается доfloat;
  3. в противном случае . Если один из операндов естьlong, то другой операнд повышается доlong;
  4. в противном случае оба операнда повышаются до int.
Резюме: Правила преобразования типов для унарных операций

Правила продвижения типа для унарных операций (например. Negate '-') можно суммировать следующим образом:

  1. Если операнд равен double, float, longили int, то продвижение отсутствует;
  2. в противном случае операнд равенbyte,short,char, операнд повышается до int.

4.4 Подробнее об арифметических операторах

Оператор модуля (остатка)

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

Например,

  • -5 % 2 ⇒ -3 % 2 ⇒ -1
  • 5.5 % 2.2 ⇒ 3.3 % 2.2 ⇒ 1.1
Экспонента?

В Java нет оператора экспоненты. (^Оператор обозначает exclusive-or. А НЕ exponent). Вам нужно использовать метод JDK Math.exp(x, y)для оценки xповышения мощности yили написать свой собственный код.

4.5 Переполнение/Недостаточный поток

Изучите результаты следующей программы:

 Тест переполнения публичного класса { public static void main(String[] args) { int i1 = 2147483647; System.out.println(i + 1); System.out.println(i + 2); System.out.println(i + 3); System.out.println(i * 2); System.out.println(i * i); int i2 = -2147483648; System.out.println(i2 - 1); System.out.println(i2 - 2); System.out.println(i2 * i2); 

В арифметических операциях результирующее значение обтекается. Если оно превышает свой диапазон (то есть переполняется). Java runtime НЕ выдает сообщение об ошибке/предупреждении. Но выдает неправильный результат.

С другой стороны. Целочисленное деление дает усеченное целое число и приводит к так называемому недостаточномупотоку . Например, 1/2дает 0, а 0.5не . Опять же, Java runtime не выдает сообщение об ошибке/предупреждении. А выдает неточный результат.

Важно отметить. Что проверка переполнения/недопуска-это ответственность программиста, то есть ваша работа!!!

Почему компьютер не помечает overflow/underflow как ошибку? Это связано с устаревшим дизайном. Когда процессоры были очень медленными. Проверка переполнения/underflow потребляет вычислительную мощность. Сегодня процессоры работают быстро. Лучше попросить компьютер проверить переполнение/underflow (если вы разрабатываете новый язык). Потому что мало кто ожидает таких результатов.

Проверять арифметическое переполнение (известное как безопасное кодирование) утомительно. Google для Убедитесь. Что операции со знаковыми целыми числами не приводят к переполнению

4.6 Больше на Integer против Числа с плавающей запятой

Целые числа (byte, short, int, long) являются точными (точными). Но floatи doubleне точные. А близкие приближения. Изучите результаты следующей программы:

 тестовая точность открытого класса { public static void main(String[] args) { System.out.println(2.2 + 4.4); 6.6000000000000005 System.out.println(6.6 - 2.2 - 4.4); System.out.println((6.6) == (2.2 + 4.4)); int i1 = 123456789; System.out.println(i1*10); float f1 = 123456789.0 f; System.out.println(f1); System.out.println(f1*10); 

Всегда используйтеint, если вам не нужна дробная часть. Хотя doubleона также может представлять большинство целых чисел (например,,1.0,2.0,3.0). Это потому что:

  • int это более эффективно (быстрее). Чем doubleв арифметических операциях.
  • 32-битная intверсия занимает меньше места в памяти. Чем 64-битная double.
  • int является точным (точным) в представлении ВСЕХ целых чисел в пределах своего диапазона. double это аппроксимация — НЕ ВСЕ целочисленные значения могут быть представлены double.

4.7 Тип Литья

В Java вы получите компиляцию double|float|longtointdoubleпеременной значение , float, или longзначение ofint. Это происходит потому. Что дробная часть будет усечена и потеряна. Например,

 двойной d = 3,5; int i = d; Ошибка компиляции: несовместимые типы: возможное преобразование с потерями из double в int  Ошибка компиляции: несовместимые типы: возможное преобразование с потерями из float в int длинный lg = 123; int count = lg; Ошибка компиляции: несовместимые типы: возможное преобразование с потерями из long в int
Явное приведение типов и Оператор приведения типов

Чтобы присвоить doubleзначение a intпеременной. Вам нужно вызвать так называемый оператор приведения типов-в форме(int)doubleOperand-для работы с doubleоперандом и возврата усеченного значения in int. Другими словами. Вы говорите компилятору. Что сознательно выполняете усечение. И полностью осознаете Затем вы можете присвоить переменной усеченное intзначениеint. Например,

двойной d = 3,5; int i; i = (int)d; 

Приведение типов-это операция. Которая принимает один операнд. Он оперирует своим операндом и возвращает эквивалентное значение в указанном типе. Синтаксис таков:

(тип)переменная (type)literal 

В Java существует два вида приведения типов:

  1. Явное приведение типов с помощью оператора приведения типов. Как описано выше, и
  2. Неявное приведение типов выполняется компилятором автоматически. Если нет потери точности.
Неявное приведение типов в присваивании

Явное приведение типов не требуется. Если вы присваиваете intзначение doubleпеременной. Потому что нет потери точности. Компилятор будет выполнять приведение типов автоматически (т. Е. неявное приведение типов). Например,,

int i = 3; двойной d; d = i; d = (double)i; double aDouble = 55; double nought = 0; 

На следующей диаграмме показан порядок неявного приведения типов. Выполняемого компилятором. Правило состоит в том. Чтобы продвинуть меньший тип к большему типу. Чтобы предотвратить потерю точности. Известную как расширяющееся преобразование. Сужающее преобразование требует явного приведения типов. Чтобы сообщить компилятору. Что вы знаете о возможной потере точности. Обратите внимание. Что charэто рассматривается как целое число в диапазоне [0, 65535]. boolean значение не может быть приведено к типу (т. Е. преобразовано в не-boolean).

JavaBasics_ImplicitTypeCastingPrimitives.png

Пример: Предположим. Что вы хотите найти среднее значение (in double) бегущих целых чисел из 1и 100. Изучите следующий код:

1 2 3 4 5 6 7 8 9 10 11 12
 публичный класс average1 to100 { public static void main(String[] args) { int sum = 0; двойная средняя; для (int number = 1; number) { sum += number; average = sum / 100; System.out.println(Average is 50.0

Это average50.0неверно. Это потому. Что и то sumи 100другое есть int. Результатом int/intявляется an int, который затем неявно приводится к doubledoubleпеременной и присваивается averageей . Чтобы получить правильный ответ. Вы можете сделать либо:

average = (double)sum / 100; average = sum / (double)100; average = sum / 100.0; average = (double)(sum / 100); 

4.8 Составные операторы назначения

Помимо обычного простого оператора присваивания (=), описанного ранее. Java также предоставляет так называемый составной оператор присваиванияs в списке:

Операция Режим Использование Описание Пример
= Двоичный var = expr Назначение
Присвоите переменной RHS значение LHS
x = 5;
+= Двоичный var += expr
так же. Как: var = var + expr
Сложение и присвоение составных чисел x += 5;
то же самое. Что: x = x + 5
-= Двоичный var -= expr
так же. Как: var = varexpr
Сложное вычитание и присвоение x -= 5;
то же. Что: x = x — 5
*= Двоичный var *= expr
так же. Как: var = var * expr
Сложное умножение и присвоение x *= 5;
то же самое. Что: x = x * 5
/= Двоичный var /= expr
то же самое. Что: var = var / expr
Составное деление и назначение x /= 5;
то же самое. Что: x = x / 5
%= Двоичный var %= expr
так же. Как: var = var % expr
Составные модуль (остаток) и назначение x %= 5;
то же самое. Что: x = x % 5

Одно тонкое различие между простыми и составными операторами заключается в byteshortcharдвоичных операциях. Для примера,

байт b1 = 5, b2 = 8, b3; b3 = (byte)(b1 + b2); b3 = b1 + b2; b1 += b2; char c1 = '0'. C2; c2 = (char)(c1 + 2); c2 = c1 + 2; c1 += 2; 

4.9 Инкремент/Декремент

Java поддерживает эти унарные арифметические операторы: increment (++) и decrement (--) для всех примитивных типов чисел (byte, short, char, int, long, floatи double, кроме boolean). Унарные операторы инкремента/декремента могут быть размещены перед операндом (префиксом) или после операндов (постфиксом). Эти операторы были введены в C++ для сокращения x=x+1x++or ++x.

Оператор Режим Использование Описание Пример
++
(Инкремент)
Унарный Префикс
Унарный Постфикс
++x
x++
Увеличьте значение операнда на 1.
x++ или ++x-это то же самое, что x += 1 или x = x + 1
int x = 5;
x++;
++x;

(Декремент)
Унарный Префикс
Унарный Постфикс
--x
x--
Уменьшите значение операнда на 1.
x— или —x-это то же самое, что x — = 1 или x = x- 1
int y = 6;
y—;
—y;

Инкремент (++) и декремент (--) работают над своим единственным операндом и сохраняют результат обратно в свой операнд. Например, ++xизвлекает x. Увеличивает его и сохраняет результат обратно в x.

В Java существует 4 способа увеличения/уменьшения переменной:

int x = 5; x = x + 1; x += 1; x++; ++x; x = x - 1; x -= 1; x--; --x; 

В отличие от других унарных операторов (таких как negate (-)), которые продвигают byteshortи charк int, инкремент и декремент не продвигают его операнд. Потому что в этом нет такой необходимости.

Унарный оператор инкремента/декремента может быть помещен перед операндом (префиксом) или после операндов (постфиксом). Что может повлиять на результат.

  • Если эти операторы используются сами по себе (автономно) в операторе (например, x++; или ++x;), результаты одинаковы для пред — и пост-операторов. См. Примеры выше.
  • Если ++или --включает в себя другую операцию в том же операторе, например, y = x++;или y = ++x;если в одном операторе есть две операции: присваивание и приращение. То до или после порядка важно указать порядок этих двух операций. Как показано в таблице ниже:
Оператор Описание Пример То Же Самое, Что
++var
(Предварительный инкремент)
Увеличьте varи верните увеличенный var для другой операции в том же операторе. y = ++x; x = x + 1;
y = x;
var++
(Постинкремент)
Верните старое значение var для другой операции в том же операторе. А затем увеличьте var. y = x++; oldX = x;
x = x + 1;
y = oldX;
—var
(Pre-Decrement)
Уменьшите varи верните уменьшенный var для другой операции в том же операторе. y = —x; x = x — 1;
y = x;
var—
(Пост-Декремент)
Верните старое значение var для другой операции в том же операторе. А затем уменьшите var. y = x—; oldX = x;
x = x — 1;
y = oldX;

Для примера,

 x = 5; y = ++x; x = 5; y = x++; x = 5; System.out.println(++x); x = 5; System.out.println(x++); 

Примечания:

  • Префиксный оператор (например, ++i) может быть более эффективным. Чем постфиксный оператор (например, i++)?!
  • Что это i=i++? Попробуйте!

4.10 Реляционные и логические операторы

Очень часто вам нужно сравнить два значения. Прежде чем принять решение о действии, например. Если отметка больше или равна 50, выведите

Java предоставляет шесть операторов сравнения (или реляционных операторов). Все эти операторы являются двоичными операторами (которые принимают два операнда) и возвращают booleanзначение либо trueили false.

Оператор Режим Использование Описание Пример (x=5, y=8)
== Двоичный x == y Равно (x == y) ⇒ ложь
!= Двоичный x != y Не равны (x != y) ⇒ истина
> Двоичный x > y Больше, чем
>= Двоичный x >= y Больше или равно
Двоичный x Меньше, чем (y
Двоичный x Меньше или равно (y

Обратите внимание. Что операторы сравнения-это бинарные инфиксные операторы. Которые оперируют двумя операндами с оператором между ними. Например x . Недопустимо писать 1 (не двоичные операции). Вместо этого вам нужно разбить две бинарные операции сравненияx > 1,x , и объединить их с логическим оператором AND . То есть,(x > 1) && (x . Где &&обозначает оператор AND.

Java предоставляет четыре логических оператора. Которые работают booleanтолько с операндами. В порядке убывания приоритета. Следующим образом:

Оператор Режим Использование Описание Пример
! Унарный !x Логично НЕТ  
&& Двоичный x && y Логично И  
|| Двоичный x || y Логично ИЛИ  
^ Двоичный x ^ y Логическое Исключающее-ИЛИ (XOR)  

Таблицы истинности выглядят следующим образом:

НЕТ (!) истинный ложный
Результат ложный истинный

И(&&) истинный ложный
истинный истинный ложный
ложный ложный ложный

ИЛИ (||) истинный ложный
истинный истинный истинный
ложный истинный ложный

XOR (^) истинный ложный
истинный ложный истинный
ложный истинный ложный

Примеры:

   ((год % 4 == 0) && (год % 100 != 0)) || (год % 400 = = 0)

Упражнение: Изучите следующую программу и объясните ее результаты.

 public class RelationalLogicalOpTest { public static void main(String[] args) { int age = 18 лет; двойной вес = 71,23; внутренний рост = 191; логическое значение женат = ложь; boolean attached = false; char gender = 'm'; System.out.println(!married && !attached && (gender == 'm')); System.out.println(married && (gender == 'f')); 

Напишите выражение для всех неженатых мужчин в возрасте от 21 до 35 лет. С ростом выше 180 и весом от 70 до 80.

Упражнение: Учитывая значения yearmonth(1-12) и day(1-31). Напишите booleanвыражение. Которое возвращает trueдаты до 15 октября 1582 года (дата сокращения по григорианскому календарю).

Ans: (year

Сравнение Равенства ==

Вы можете использовать ==для сравнения два целых числа (byte, short, int, long) и char. Но не используйте ==для сравнения два числа с плавающей запятой (float иdouble), потому что они НЕ точны. Чтобы сравнить числа с плавающей запятой. Установите порог их разности, например,

открытый класс FloatComparisonTest { public static void main(String[] args) { двойной d1 = 2,2 + 4,4; двойной d2 = 6,6; System.out.println(d1 == d2); System.out.println(d1); final double EPSILON = 1e-7; System.out.println(Math.abs(d1 - d2) 

Вы также НЕ МОЖЕТЕ использовать ==его для сравнения двух Strings, потому Stringчто s-это объекты. Вам нужно использовать str1.equals(str2)вместо этого. Об этом мы поговорим позже.

Приоритет логических операторов

Приоритет от высшего к низшему равен: '!'(унарный), '^', '&&', '||‘. Но если вы сомневаетесь. Используйте круглые скобки!

System.out.println(true || true && false); System.out.println(true || (true && false)); System.out.println((true || true) && false); System.out.println(false && true ^ true); System.out.println(false && (true ^ true)); System.out.println ((false && true) ^ true); 
Операции короткого замыкания

Двоичные операторы AND (&&) и OR (||) известны как операторы короткого замыкания. Что означает. Что правый операнд не будет вычислен. Если результат может быть определен левым операндом. Например, false && rightOperand дает false и true || rightOperand дает true без оценки правого операнда. Это может иметь неблагоприятные последствия. Если вы полагаетесь на правый операнд для выполнения определенных операций. Напримерfalse && (++i , но ++i не будете оценены.

4.11 Строка и оператор конкатенации ‘+’

В Java '+'это специальный оператор. Он перегружен. Перегрузка означает. Что он выполняет различные операции в зависимости от типов своих операндов.

  • Если оба операнда числовые (byte, short, int, long,float,double,char), '+'выполняет обычное сложение. Для примера,
    1 + 2 ⇒ 3 1.2 + 2.2 ⇒ 3.4 1 + 2.2 ⇒ 1.0 + 2.2 ⇒ 3.2 '0' + 2 ⇒ 48 + 2 ⇒ 50 
  • Если оба операнда равны Strings, '+' то конкатенирует два Strings и возвращает конкатенированное String. Для примера,
    
    
  • Если один из операндов равен aString, а другой-числовой. То числовой операнд будет преобразован в Stringa и два Strings объединены, например,
    
    

Мы часто используем Stringоператор конкатенации '+'в print()и println()для получения желаемого результата String. Для примера,

System.out.println( System.out.println(

5. Управление Потоком

Существует три основные конструкции управления потоком — последовательная, условная (или решение) и циклическая (или итерация), как показано ниже.

структурные конструкции

5.1 Последовательное Управление Потоком

flow_sequential.gif

Программа-это последовательность инструкций. Выполняемых одна за другой предсказуемым образом. Последовательный поток является наиболее распространенным и прямолинейным. Где операторы программирования выполняются в том порядке. В котором они записаны-сверху вниз последовательным образом.

5.2 Условное Управление Потоком

Существует несколько типов условных выражений: if-then, if-then-else, nested-if, switch-case-defaultи условное выражение.

если-тогда и если-тогда —еще
Синтаксис Пример Блок-схема
 if (booleanTest) { TrueBlock; } 
System.out.println(System.out.println(System.out.println(
Flowchart_IfThen.png
 if (booleanTest) { TrueBlock; } else { falseBlock; } 
int mark = 50; System.out.println(System.out.println(} else { System.out.println(System.out.println(} еще { System.out.println(
Flowchart_IfElse.png

Брекеты: Вы можете опустить фигурные скобки { }, если внутри блока есть только один оператор. Например,

 int absValue = -5; если (absValue 

Однако я рекомендую вам сохранить фигурные скобки. Чтобы улучшить читаемость вашей программы. Даже если в блоке есть только один оператор.

Вложенный —если
Синтаксис Пример Блок-схема
 if (booleanTest1) { block1; } else if (booleanTest2) { block2; } else if (booleanTest3) { block3; } else if (booleanTest4) { ...... } else { elseBlock; } 
int mark = 62; System.out.println( System.out.println( System.out.println(} else { System.out.println( System.out.println( System.out.println(} else { System.out.println(
Flowchart_NestedIf.png

Java не предоставляет отдельного синтаксиса для вложенных-if (например. С ключевыми словами, какeif,elseif), но поддерживает вложенные-if с вложенными операторами if-else. Который интерпретируется как ниже. Обратите внимание. Что вам нужно поставить пробел между elseи.if Запись elseifвызывает синтаксическую ошибку.

if ( booleanTest1 ) { блок1; } else { if ( booleanTest2 ) { блок2; } else { if (booleanTest3) { блок3; } else { if ( booleanTest4 ) { ...... } еще {  elseBlock

Flowchart_NestedIf_Interpretation

Однако для удобства чтения рекомендуется выровнять оператор nest-if. Как написано в синтаксисе/примерах.

Обратите внимание. Что блоки являются исключительными в вложенном операторе-if; только один из блоков будет выполнен. Также есть два способа написания вложенных-если, например,

 System.out.println( System.out.println( System.out.println(} else { если (пометка 
Болтается —еще проблема

Проблему else

int i = 0, j = 0; if (i == 0) if (j == 0) System.out.println(else System.out.println(

elseПредложение в приведенном выше коде синтаксически применимо как к внешнемуif , так и к внутреннемуif, вызывая проблему зависанияelse.

Компилятор Java решает проблему зависанияelse, связывая elseпредложение с самым внутреннимif (то есть ближайшимif). Следовательно. Вышеприведенный кодекс должен толковаться как:

int i = 0, j = 0; if (i == 0) если (j == 0) System.out.println(else System.out.println(

Свисание —else можно предотвратить. Применив явные круглые скобки. Например. Если вы хотите связать elseпредложение с внешним-if, сделайте это:

int i = 0, j = 0; if (i == 0) { if (j == 0) System.out.println(} еще { System.out.println( int i = 0, j = 0; if (i == 0) { if (j == 0) { System.out.println(} еще { System.out.println(
Вложенный —если против Последовательного —если

Изучите следующий код:


switch-case-default
Синтаксис Пример Блок-схема
 переключатель по умолчанию (селектор) { case value1: block1; break; case value2: block2; break; case value3: block3; break; ......  case valueN: blockN; break;  default: defaultBlock; } 
 int число = 3; switch (number) { case 1: System.out.println(случай 2: System.out.println(случай 3: System.out.println(По умолчанию: оператор char = '*'; int num1 = 5, num2 = 8, результат; switch (operator) { '+': результат = num1 + num2; разрыв; дело результат = num1 - num2; перерыв; дело результат = num1 * num2; разрыв; дело '/': результат = num1 / num2; перерыв; По умолчанию: 
Flowchart_SwitchCase.png

switch-case-defaultifтестов с фиксированным значением (но не применяется для тестов диапазона). intbyteshortВ качестве case-селектора можно использовать переменную , , char, или , но НЕ long, float, doubleи boolean. JDK 1.7 поддерживает Stringв качестве case-селектора.

В switch-casebreakзаявлении требуется заявление для каждого из случаев. Если breakон отсутствует. То выполнение будет протекать через следующий случай. Который обычно является ошибкой. Однако мы могли бы использовать это свойство для обработки многозначного селектора. Например,

 char inChar = 'x'; switch (inChar) { case 'a': case 'b': case 'c': System.out.print(2); break; случай System.out.print(3); break; случай System.out.print(4); break; случай System.out.print(5); break; ...... По умолчанию: 
Условное выражение ( … ?: … )

Условный оператор-это тернарный (3-операнд) оператор в форме booleanExpr ? trueExpr : falseExpr. В зависимости от booleanExprэтого . Он оценивает и возвращает значение trueExpror falseExpr.

Синтаксис Примеры
 booleanExpr ? trueExpr : falseExpr 
int num1 = 9, num2 = 8, макс.; num1 : num2; max = num1; } еще { int value = -9, absValue; else absValue = -значение; int mark = 48; else System.out.println(

Условное выражение-это короткая рука для if-else. Но вы должны использовать его только для однострочника, для удобства чтения.

5.3 Упражнения по началу работы и условному

ССЫЛКА

5.4 Управление потоком Контура

Опять же. Существует несколько типов циклов: for, while-doи do-while.

Синтаксис Пример Блок-схема
 while (booleanTest) { body; }   
 int sum = 0; final int UPPERBOUND = 100; int number = 1; while (число) { сумма += число; ++number; System.out.println( int n = 5; int factorial = 1; int number = 1; while (число) { факториал *= число; ++num; System.out.println(
Flowchart_While.png
 do { bodywhile (booleanTest); 
 int sum = 0; final int UPPERBOUND = 100; int number = 1; делать { сумма += число; ++number; } while (число); System.out.println( int n = 5; int factorial = 1; int number = 1; делать { факториал *= число; ++number; } while (число); System.out.println(
Flowchart_DoWhile.png
 for (init; booleanTest; update) { body; }   
 int sum = 0; final int UPPERBOUND = 100; for (int number = 1; number) { System.out.println( int n = 5; int factorial = 1; for (int number = 1; number) { System.out.println(
Flowchart_For.png

Разница между while-do и do-while заключается в порядке тела и теста. В то время как-до , тест проводится в первую очередь. Тело будет выполнено. Если тест верен и процесс повторяется. В do-whileтело выполняется . А затем test выполняется. Обратите внимание. Что тело do-while выполняется по крайней мере один раз (1+); но тело while-do, возможно. Равно нулю (0+). Аналогично, тело for-loop может не выполняться (0+).

For-loop-это сокращение от while-do с меньшим количеством строк кода. Это наиболее часто используемая петля. Особенно если известно количество повторений. Но его синтаксис труднее понять. Убедитесь. Что вы понимаете for-loop. Пройдясь по блок-схеме и примерам.

Переменная Индекса/Счетчика цикла

Циклом обычно управляет переменная индекса или счетчика. Например,

 int sum = 0 final int UPPERBOUND = 100; for (int number = 1; number 

В приведенных выше примерах переменная numberслужит индексной переменной. Которая принимает значения1,2,3,…, UPPERBOUNDдля каждой итерации цикла. Вам нужно явно увеличить/уменьшить/изменить индексную переменную (например. Через ++number). В противном случае цикл становится бесконечным циклом. Так как тест (number будет возвращать один и тот же результат для одного и того же значения number.

Обратите внимание. Что for-loop-это сокращение от while-loop. И for-loop, и while-loop имеют один и тот же набор операторов. Но for-loop переупорядочивает операторы.

Для циклаfor-loop индексная переменная numberобъявляется внутри цикла и. Следовательно. Доступна только внутри цикла. Вы не можете получить доступ к переменной после цикла. Так как она уничтожается после цикла. С другой стороны. Для whileцикла-переменная индекса numberдоступна внутри и вне цикла.

Для циклаfor-loop вы можете объявить индексную переменную внутри цикла или вне цикла. Мы рекомендуем объявить его внутри цикла. Чтобы сохранить продолжительность жизни этой переменной там. Где она необходима. А не больше.

[TODO] Анимированный GIF??

Пример кода: Сумма и среднее значение запущенных целых чисел

Следующая программа суммирует текущие целые числа от заданной нижней границы до верхней. Также вычислите их среднее значение.

 публичный класс SumAverageRunningNumbers { public static void main(String[] args) { int sum = 0; final int LOWERBOUND = 1; final int UPPERBOUND = 1000; двойная средняя; for (int number = LOWERBOUND; number) { сумма += число; } average = (double)sum / (UPPERBOUND - LOWERBOUND + 1); System.out.println( System.out.println( int count = 0; sum = 0; final int ADJUSTED_LOWERBOUND = LOWERBOUND % 2 = = 0 ? НИЖНЯЯ ГРАНИЦА+1 : НИЖНЯЯ ГРАНИЦА; for (int number = ADJUSTED_LOWERBOUND; number) { ++граф; сумма += число; } среднее значение = (двойная)сумма / количество; System.out.println( System.out.println(
Использование логического флага для управления циклом

Помимо использования индексной переменной для управления циклом. Другим распространенным способом управления циклом является booleanфлаг.

Пример: Ниже приведен пример использования while-do с booleanфлагом. booleanФлаг инициализируетсяfalse, чтобы убедиться. Что цикл введен.

 boolean GameOver = false; в то время как (!GameOver) { ...... if ( ...... ) { GameOver = true; 

Пример: Предположим . Что ваша программа запрашивает у пользователя число между 1to 10и проверяет правильность ввода. Цикл do-while с booleanфлагом может быть более подходящим. Поскольку он запрашивает ввод по крайней мере один раз и повторяется снова и снова. Если ввод недопустим.

 логический isValid = false; int число; делать { ...... isValid = true; ...... } еще { } while (!isValid); 
for-loop с разделителем запятых

Вы можете поместить несколько операторов в init и update, разделенных запятыми. Например,

 for (int row = 0, col = 0; row) { 

Однако тестдолжен быть логическим выражением. Которое возвращает логическое trueили false.

5.5 Завершающая программа

System.exit(int ExitCode): Вы можете вызвать метод System.exit(int exitCode)для завершения работы программы и возврата элемента управления в среду выполнения Java. По соглашению нулевой код возврата указывает на нормальное завершение. А ненулевой-exitCodeна ненормальное завершение. Например,

System.out.println(System.exit(1); 

Оператор return: Вы также можете использоватьreturnоператор main()методе для завершения main()и возврата элемента управления обратно в среду выполнения Java. Например,

public static void main(String[] args) { ... System.out.println(return; 

5.6 Упражнения по принятию решений и циклу

ССЫЛКА

6. Вход/Выход

6.1 Форматированный вывод через printf()

System.out.print() и println()не предоставляйте форматирование вывода. Такое как управление количеством пробелов для печати an intи количеством десятичных знаков для a double.

Java SE 5 представил новый метод. Называемый printf()для форматированного вывода (который моделируется после языка C printf()). printf() принимает следующую форму:

printf(formattingString, arg1, arg2, arg3, ... );

Форматирование-строка содержит как обычные тексты, так и так называемый спецификатор форматаs. Обычные тексты (включая пробелы) будут напечатаны так. Как они есть. Спецификаторы формата. В виде %[flags][width]conversionCodeformattingString, как правило. Один к одному и последовательным образом. Описатель формата начинается с a '%'и заканчивается conversionCode, например, %dдля целого числа, %fдля числа с плавающей запятой (float и double), %cдля charи %sдля String. Опционально widthможно вставить между ними. Чтобы указать ширину поля. Аналогично, опционально flagsможно использовать для управления выравниванием. Прокладкой и другими. Для примера,

  • %d, %αd: целое число. Напечатанное через α пробелов (α необязательно). Выровнено по правому краю. Если α опущено. То число пробелов равно длине целого числа.
  • %s, %αs: Строка печатается через α пробелов (α необязательно). Выровненная по правому краю. Если α опущено. То количество пробелов равно длине строки (чтобы она соответствовала строке).
  • %f, %α.βf, %.βf: Число с плавающей запятой (float и double) печатается через α — пробелы с β-десятичными цифрами (α и β являются необязательными). Если α опущено. То число пробелов равно длине числа с плавающей запятой.
  • %n: новая строка для конкретной системы (Windows использует "\r\n", Unix и macOS "\n").
Примеры:
Пример Выход
 System.out.printf(%s|%d|%f|,@xyz%n
Привет,|Привет|123|45.600000|,@xyz 
 System.out.printf(%6s|%6d|%6.2 f|,@xyz%n
Привет,| Привет| 123| 45.60|,@xyz 
 System.out.printf(%d|%5d|%-5d|%05d|,@xyz%n
Привет,|111| 222/333 |00444|,@xyz 
 System.out.printf(%f|%7.2 f|%.2f|%-7.2 f|,@xyz%n
Привет,|11.100000| 22.20|33.30|44.40 |,@xyz 
 System.out.printf(%.2f%%.%n
Ставка составляет: 1,20%. 

Обратите внимание. Что printf()после печати курсор не перемещается на следующую строку. Вам нужно явно напечатать символ новой строки (via %n) в конце строки форматирования. Чтобы переместить курсор на следующую строку. Если это необходимо. Как показано в приведенных выше примерах.

В Java есть еще много спецификаторов формата. Подробные описания см. в Документации JDK (@ https://docs.oracle.com/javase/10/docs/api/java/util/Formatter.html для JDK 10).

(Также обратите внимание. Что printf()возьмите переменное количество аргументов (или varargs), что является новой функцией. Введенной в JDK 5 для поддержкиprintf())

6.2 Ввод С клавиатуры через Сканер

Java, как и все другие языки. Поддерживает три стандартных потока ввода/вывода: System.in(стандартное устройство ввода), System.out(стандартное устройство вывода) и System.err(стандартное устройство ошибок). По System.inумолчанию используется клавиатура; в то время System.outкак и System.errпо умолчанию используется консоль дисплея. Они могут быть перенаправлены на другие устройства, например. Довольно часто перенаправляются System.errна дисковый файл. Чтобы сохранить эти сообщения об ошибках.

Вы можете считывать ввод с клавиатуры через System.in(стандартное устройство ввода).

JDK 5 ввел новый класс. Называемый Scannerin packagejava.util, для упрощения форматированного ввода (и новый метод printf()форматированного вывода. Описанный ранее). Вы можете построить a Scannerдля сканирования ввода с System.inклавиатуры и использовать такие методы. Как nextInt(), nextDouble(), next()для разбора следующего int, doubleи Stringтокен (разделенный пробелом пустого. Табуляции и новой строки).

импорт java.util.Сканер; публичный класс ScannerTest { public static void main(String[] args) { int num1; двойной num2; Строка str; Сканер in = новый сканер(System.in); System.out.print( num1 = in.nextInt(); System.out.print( num2 = in.nextDouble(); System.out.print( str = in.next(); в.close(); 

Вы также можете использовать метод nextLine()для чтения всей строки. Включая пробелы. Но исключая конечную новую строку.

 импорт файла java.util.Сканер; публичный класс ScannerNextLineTest { public static void main(String[] args) { Scanner in = новый сканер(System.in); System.out.print( String str = in.nextLine(); in.close(); 

Старайтесь не смешивать nextLine()и nextInt()|nextDouble()|next()в программе (так как вам может понадобиться смыть новую строку из входного буфера).

ScannerПоддерживает множество других форматов ввода. Проверьте страницу документации JDK в разделе module java.base⇒ package java.util⇒ class Scanner⇒ Method (@ https://docs.oracle.com/javase/10/docs/api/java/util/Scanner.html для JDK 10).

6.3 Пример кода: Запросите у пользователя Два целых числа и выведите их сумму

Следующая программа запрашивает у пользователя два целых числа и выводит их сумму. Для примера,

Введите первое целое число: 8 Введите второе целое число: 9 Сумма составляет: 17
импорт java.util.Сканер; public class Add2Integer { public static void main (String[] args) { int number1, number2, sum; Сканер in = новый сканер(System.in); System.out.print( number1 = in.nextInt(); System.out.print(number2 = in.nextInt(); in.close(); сумма = число 1 + число 2; System.out.println(

6.4 Пример кода: Калькулятор подоходного налога

Прогрессивная ставка подоходного налога устанавливается следующим образом:

Налогооблагаемый Доход Оценить (%)
Первые 20 000 долларов 0
Следующие 20 000 долларов 10
Следующие 20 000 долларов 20
Остальные 30

Например, предположим , что налогооблагаемый доход равен$85000, а подлежащий уплате подоходный налог $20000*0% + $20000*10% + $20000*20% + $25000*30%равен .

Напишите программу под названиемIncomeTaxCalculator, которая считывает налогооблагаемый доход (in int). Программа рассчитает подлежащий уплате подоходный налог (in double) и выведет результат. Округленный до 2 знаков после запятой.

Введите налогооблагаемый доход: $41234 Подоходный налог. Подлежащий уплате. Составляет: $2246,80 Введите налогооблагаемый доход: $67891
Подлежащий уплате подоходный налог составляет: $8367,30 Введите налогооблагаемый доход: $85432 Подоходный налог. Подлежащий уплате. Составляет: $13629,60 Введите налогооблагаемый доход: $12345 Подоходный налог. Подлежащий уплате. Составляет: $0.00
импорт java.util.Сканер; публичный класс IncomeTaxCalculator { public static void main(String[] args) { final double TAX_RATE_ABOVE_20K = 0.1; окончательный двойной НАЛОГ_RATE_ABOVE_40K = 0,2; окончательный двойной НАЛОГ_RATE_ABOVE_60K = 0.3; int taxableIncome; двойной налогоплательщик; Scanner in = новый сканер(System.in); System.out.print(taxableIncome = in.nextInt(); in.close(); если (taxableIncome 

6.5 Пример кода: Калькулятор подоходного налога с помощью Sentinel

Основываясь на предыдущем примере. Напишите программу, IncomeTaxCalculatorSentinelкоторая будет повторять вычисления до тех пор. Пока пользователь не войдет -1. Например,

Введите налогооблагаемый доход: $41000 Подоходный налог. Подлежащий уплате. Составляет: $2200,00 Введите налогооблагаемый доход: $62000 Подлежащий уплате подоходный налог составляет: $6600,00 Введите налогооблагаемый доход: $73123 Подоходный налог. Подлежащий уплате. Составляет: $9936,90 Введите налогооблагаемый доход: $84328 Подлежащий уплате подоходный налог составляет: $13298,40 Введите налогооблагаемый доход: $-1 до свидания!

-1Это значение известно как сторожевое. (В программировании сторожевое значение, также называемое значением флага. Значением отключения. Значением изгоя. Значением сигнала или фиктивными данными. Является специальным значением. Которое использует свое присутствие в качестве условия завершения.)

импорт java.util.Сканер; публичный класс IncomeTaxCalculatorSentinel { public static void main(String[] args) { окончательный двойной TAX_RATE_ABOVE_20K = 0.1; окончательный двойной НАЛОГ_RATE_ABOVE_40K = 0,2; окончательный двойной НАЛОГ_RATE_ABOVE_60K = 0.3; final int SENTINEL = -1; int taxableIncome; двойное налогообложение; Scanner in = новый сканер(System.in); System.out.print(taxableIncome = in.nextInt(); while (taxableIncome != SENTINEL) { Налогоплательщик = 20000 * TAX_RATE_ABOVE_20K + 20000 * TAX_RATE_ABOVE_40K + (taxableIncome - 60000) * TAX_RATE_ABOVE_60K; Налогоплательщик = 20000 * TAX_RATE_ABOVE_20K + (taxableIncome - 40000) * TAX_RATE_ABOVE_40K; taxPayable = (taxableIncome - 20000) * TAX_RATE_ABOVE_20K; } еще { System.out.printf( System.out.print(taxableIncome = in.nextInt(); System.out.println(in.close(); 

Примечания:

  1. Шаблон кодирования для обработки входных данных со сторожевым (завершающим) значением выглядит следующим образом:
     вход = ......; while (input != SENTINEL) { ...... ...... вход = ......; 

6.6 Пример Кода: Угадайте Число

Угадайте число между 0 и 99.

импорт java.util.Сканер; номер публичного класса { public static void main(String[] args) { final int SECRET_NUMBER; int numberIn; int trialNumber = 0; boolean done = false; Scanner in = новый сканер(System.in); SECRET_NUMBER = (int)(Math.random()*100); пока (!сделано) { ++Пробный номер; System.out.print(numberIn = in.nextInt(); if (numberIn == SECRET_NUMBER) { System.out.println(сделано = истина; } else if (numberIn) { System.out.println(} еще { System.out.println(

Примечания:

  1. Приведенная выше программа использует booleanфлаг для управления циклом в следующем шаблоне кодирования:
    boolean done = false; в то время как (!сделано) { if (.....) { done = true; ...... 

6.7 Упражнения на принятие решения/Цикл с вводом

ССЫЛКА

6.8 Ввод из текстового файла через Сканер

Кроме сканирования System.in(клавиатура). Вы можете подключить Scannerк сканированию любые источники ввода. Такие как дисковый файл или сетевой сокет, и использовать тот же набор методов nextInt(), nextDouble(), next(), nextLine()для разбора следующей intстроки,double, Stringи. Например,

Scanner in = новый сканер(новый файл( int anInt = in.nextInt(); double aDouble = in.nextDouble(); String str = in.next(); String line = in.nextLine(); 

Чтобы открыть файл через new File(filename)него . Вам нужно обработать так называемый FileNotFoundException, то есть файл. Который вы пытаетесь открыть. Не может быть найден. В противном случае вы не сможете скомпилировать свою программу. Есть два способа справиться с этим исключением: throws или try-catch.

 import java.util.Scanner; import java.io.File; import java.io.FileNotFoundException; публичный класс TextFileScannerWithThrows { public static void main(String[] args) throws FileNotFoundException { int num1; двойной номер 2; Имя строки; Scanner in = new Scanner(новый файл( num1 = in.nextInt(); num2 = in.nextDouble(); name = in.next(); 

Чтобы запустить вышеприведенную программу. Создайте текстовый файл с именем in.txtcontaining:

1234 55.66 Пол
 импорт java.util.Сканер; импорта сканера java.io.File; импорт java.io.FileNotFoundException; открытый класс TextFileScannerWithCatch { public static void main(String[] args) { int num1; двойной num2; Имя строки; попробуйте { Scanner in = new Scanner(new File( num1 = in.nextInt(); num2 = in.nextDouble(); name = in.next(); System.out.printf(} catch (FileNotFoundException ex) { ex.printStackTrace(); }

6.9 Форматированный вывод в текстовый файл

Java SE 5.0 также ввела так называемый Formatterформатированный вывод (точно так же. Как Scannerи для форматированного ввода). У FormatterА есть метод под названием format(). Этот format()метод имеет тот же синтаксис , printf()что и, например. Он может использовать спецификаторы формата для указания формата аргументов. Опять же, вам нужно справиться FileNotFoundException.

 import java.io.File; импорт java.util.Форматер; импорт java.io.FileNotFoundException; открытый класс TextFileFormatterWithThrows { public static void main(String[] args) throws FileNotFoundException { Formatter out = new Formatter(new File( int num1 = 1234; двойное число 2 = 55,66; Имя строки = out.format(out.format( System.out.println(

Запустите вышеуказанную программу и проверьте выходные данные в текстовом файле out.txt

 импорт файла java.io.File; импорт java.util.Форматер; импорт java.io.FileNotFoundException; открытый класс TextFileFormatterWithCatch { public static void main(String[] args) { попробуйте { Formatter out = new Formatter(new File( int num1 = 1234; двойное число 2 = 55,66; Имя строки = out.format( out.format( out.close(); System.out.println( } catch (FileNotFoundException ex) { ex.printStackTrace(); }

6.10 Ввод через диалоговое окно

Ввод через JOptionPane

Вы также можете получать входные данные от пользователей через графическое диалоговое окно. Используя JOptionPaneкласс. Например, следующая программа предлагает пользователю ввести радиус окружности и вычисляет площадь.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
 импорт javax.swing.JOptionPane; публичный класс JOptionPaneTest { public static void main(String[] args) { Струнный радиусСтр; двойной радиус. Площадь; radiusStr = JOptionPane.showInputDialog( radius = Double.parseDouble(radiusStr); площадь = радиус*радиус*Математика.ПИ; 

Препарирование программы:

  • В строке 4 importоператор необходим для использования функции JOptionPane.
  • В строке 10 мы используем этот метод JOptionPane.showInputDialog(promptMessage)для запроса ввода пользователем входных данных. Который возвращает входные данные в виде a String.
  • Строка 11 преобразует входные Stringданные в а double, используя этот метод Double.parseDouble().

6.11 java.io.Console (JDK 1.6)

Java SE 6 представила новый java.io.Consoleкласс для упрощения ввода/вывода символов в/из системной консоли. НО Consoleкласс не работает в среде IDE (например. Eclipse/NetBeans)!!!

Чтобы использовать новый Consoleкласс. Сначала System.console()нужно извлечь Consoleобъект. Соответствующий текущей системной консоли.

Console con = System.console();

Затем можно использовать такие методы. Как readLine()чтение строки. Вы можете дополнительно включить сообщение с запросом со спецификаторами формата (например, %d, %s) в сообщение с запросом.

Строка inLine = con.readLine(); String msg = con.readLine( String msg = con.readLine(

Вы можете использовать con.printf()для форматированного вывода такие спецификаторы формата, как%d,%s. Вы также можете подключить Consoleк a Scannerдля форматированного ввода. То есть для разбора примитивов. Таких какintdouble, например,

Scanner in = новый сканер(con.reader()); int anInt = in.nextInt(); double aDouble = in.nextDouble(); Строка str = in.next(); String line = in.nextLine();
Пример:
 импорт java.io.Console; импорт java.util.Сканер; общественный класс ConsoleTest { public static void main(String[] args) { Console con = System.console(); если (con == null) { System.err.println( String name = con.readLine(; con.printf( Scanner in = new Scanner(con.reader()); con.printf(int anInt = in.nextInt(); con.printf(double aDouble = in.nextDouble(); con.printf(

ConsoleКласс также обеспечивает безопасное средство для ввода пароля с помощью метода readPassword(). Этот метод отключает эхо ввода и сохраняет пароль в a char[]вместо a String. Пароль char[]может и должен быть перезаписан. Удаляя его из памяти. Как только он больше не нужен. (Напомним. Что Strings являются неизменяемыми и не могут быть перезаписаны. Когда они будут нужны дольше. Они будут собраны в неизвестном экземпляре.)

импорт java.io.Console; импорт java.util.Массивы; публичный класс ConsolePasswordTest { статический строковый логин; статический char[] пароль; public static void main(String[] args) { Console con = System.console(); if (con == null) { System.err.println(login = con.readLine(password = con.readPassword( if (CheckPassword(логин. Пароль)) { Массивы.заполнение(пароль. ' '); статическое логическое значение CheckPassword(String login. Char[] password) { 

7. Написание Правильных и хороших программ

Важно писать программы. Которые дают правильные результаты. Также важно писать программы. Которые другие (и вы сами через три дня) могут понять. Чтобы программы можно было поддерживать. Я называю эти программы хорошими программами — хорошая программа-это больше. Чем правильная программа.

Вот предложения:

  • Следуйте установленной конвенции. Чтобы у всех была одна и та же основа понимания. Чтобы программировать на Java. Вы ДОЛЖНЫ прочитать Соглашение о коде для языка программирования Java
  • Формат и макет исходного кода с соответствующими отступами. Пробелами и белыми линиями. Используйте 3 или 4 пробела для отступа и пустые строки для разделения разделов кода.
  • Выбирайте хорошие имена. Которые являются самоописательными и значимыми. Например,,row, col, size,xMax,numStudents. Не используйте бессмысленные имена. Такие какa,b,c,d. Избегайте одноалфавитных имен (легче набирать. Но часто бессмысленных). За исключением общих имен. Таких как x, y, zдля координат и iиндекса.
  • Предоставьте комментарии. Чтобы объяснить важные. А также существенные концепции. Прокомментируйте свой код либерально.
  • Пишите свою программную документацию во время написания ваших программ.
  • Избегайте неструктурированных конструкций. Таких как breakи continue, которым трудно следовать.
  • Используйте шрифты

Подсчитано, что в течение жизненного цикла программы 20% усилий будет уходить на первоначальное создание и тестирование кода. А 80% — на последующее обслуживание и усовершенствование. Написание хороших программ. Которые следуют стандартным соглашениям. Имеет решающее значение для последующего обслуживания и улучшения!!!

7.1 Ошибки программирования: Ошибки компиляции. Времени выполнения и логические ошибки

Обычно существует три класса ошибок программирования:

  1. Ошибка компиляции (или Синтаксическая ошибка): Программа не может компилироваться. Это можно легко исправить. Проверив сообщения об ошибках компиляции. Для примера,

     Sys.out.print(ошибка: пакет Sys не существует
    Sys.out.print(^
    System.out.print(ошибка: ';' ожидаемая
    System.out.print(
    ^
  2. Ошибка выполнения: Программа может компилироваться. Но не может успешно работать. Это также можно легко исправить. Проверив сообщения об ошибках во время выполнения. Для примера,

     int count = 0, sum = 100, average; среднее = сумма / количество; Исключение в потоке ArithmeticException: / by zero System.out.printf(Исключение в потоке IllegalFormatConversionException: d != java.lang.Двойной
  3. Логическая ошибка: Программа может компилироваться и запускаться. Но дает неверные результаты (всегда или иногда). Это самая трудная ошибка для исправления. Так как нет никаких сообщений об ошибках — вы должны полагаться на проверку выходных данных. Легко обнаружить. Если программа всегда выдает неверный результат. Это чрезвычайно трудно исправить. Если программа выдает правильный результат в большинстве случаев. Но иногда неправильный результат. Например,

    System.out.println(} еще { 

    Такого рода ошибки очень серьезны. Если их не поймать до начала производства. Написание хороших программ помогает минимизировать и обнаружить эти ошибки. Для проверки правильности программы необходима хорошая стратегия тестирования. Тестирование программного обеспечения-это продвинутая тема. Которая выходит за рамки нашей текущей области.

7.2 Отладка Программ

Вот общие методы отладки:

  1. Смотрите на экран! К сожалению. Ничего не всплывет. Даже если вы будете смотреть на него очень пристально.
  2. Изучите сообщения об ошибках! Не закрывайте консоль при возникновении ошибки и не делайте вид. Что все в порядке. В большинстве случаев это помогает.
  3. Вставьте инструкции печати в соответствующие места для отображения промежуточных результатов. Он работает для простой игрушечной программы. Но он не эффективен и не эффективен для сложной программы.
  4. Используйте графический отладчик. Это самое эффективное средство. Шаг за шагом отслеживайте выполнение программы и следите за значениями переменных и выходов.
  5. Расширенные инструменты. Такие как профилировщик (необходим для проверки утечки памяти и использования метода).
  6. Выполните тестирование программы. Чтобы устранить логические ошибки.

7.3 Упражнения на принятие решения/Цикл с вводом

ССЫЛКА

7.4 Проверка Вашей программы на корректность

Как сделать так. Чтобы ваша программа всегда давала правильный результат в 100% случаев? Невозможно опробовать все возможные исходы. Даже для простой программы сложения двух целых чисел (потому что слишком много комбинаций двух целых чисел). Тестирование программ обычно включает в себя набор репрезентативных тестовых примеров. Предназначенных для выявления всех классов ошибок. Тестирование программ выходит за рамки данной статьи.

8. Подробнее о циклах — Вложенные циклы, перерыв и продолжение

8.1 Вложенные циклы

Вложенные циклы необходимы для обработки 2-мерных (или N-мерных) данных. Таких как печать 2D-шаблонов. Вложенный цикл принимает следующую форму:

для (...; ...; ...) { ...... для (...; ...; ...) { 

Flowchart_NestedForLoop.png

8.2 Примеры кода: Печать Квадратного Узора

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

Введите размер: 5 * * * * * * * * * * * * * * * * * * * * * * * * *
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
импорт java.util.Сканер; публичный класс PrintSquarePattern { public static void main (String[] args) { final int SIZE; Scanner in = новый сканер(System.in); System.out.print(SIZE = in.nextInt(); in.close(); for (int row = 1; row) { for (int col = 1; col) { 

Эта программа содержит два вложенных цикла for. Внутренний цикл используется для печати строки * Внешний цикл повторяет внутренний цикл для печати всех строк.

Шаблон кодирования: Печать 2D-Узоров

Шаблон кодирования для печати 2D-шаблонов выглядит следующим образом. Я рекомендую использовать rowи colв качестве переменных цикла. Который является самоочевидным. Вместо iand j, xand y.

for (int row = 1; row 

8.3 Примеры кода: Печать Шаблона Контрольной доски

Предположим. Что вы хотите напечатать этот шаблон вместо этого (в программе под названиемPrintCheckerPattern):

Введите размер: 6 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

Вам нужно напечатать дополнительное пространство для четных строк. Вы можете сделать это. Добавив следующий оператор перед внутренним циклом.

если ((строка % 2) == 0) { 

8.4 Пример кода: Печать Таблицы умножения

Следующая программа запросит у пользователя размер и распечатает таблицу умножения следующим образом:

Введите размер: 10 * | 1 2 3 4 5 6 7 8 9 10 -------------------------------------------- 1 | 1 2 3 4 5 6 7 8 9 10 2 | 2 4 6 8 10 12 14 16 18 20 3 | 3 6 9 12 15 18 21 24 27 30 4 | 4 8 12 16 20 24 28 32 36 40 5 | 5 10 15 20 25 30 35 40 45 50 6 | 6 12 18 24 30 36 42 48 54 60 7 | 7 14 21 28 35 42 49 56 63 70 8 | 8 16 24 32 40 48 56 64 72 80 9 | 9 18 27 36 45 54 63 72 81 90 10 | 10 20 30 40 50 60 70 80 90 100
импорт java.util.Сканер; публичный класс PrintTimeTable { public static void main(String[] args) { final int SIZE; Scanner in = новый сканер(System.in); System.out.print(SIZE = in.nextInt(); in.close(); System.out.print(for (int col = 1; col) { System.out.println(); System.out.print(for (int col = 1; col) { System.out.println(); for (int row = 1; row 

ПРОБОВАТЬ:

  1. Напишите вызываемые программы PrintPattern1x, которые запрашивают у пользователя размер и печатают каждый из этих шаблонов.
     # * # * # * # * # # # # # # # # # # # # # # # # 1 1 # * # * # * # * # # # # # # # # # # # # # # 2 1 1 2 # * # * # * # * # # # # # # # # # # # # 3 2 1 1 2 3 # * # * # * # * # # # # # # # # # # 4 3 2 1 1 2 3 4 # * # * # * # * # # # # # # # # 5 4 3 2 1 1 2 3 4 5 # * # * # * # * # # # # # # 6 5 4 3 2 1 1 2 3 4 5 6 # * # * # * # * # # # # 7 6 5 4 3 2 1 1 2 3 4 5 6 7 # * # * # * # * # # 8 7 6 5 4 3 2 1 1 2 3 4 5 6 7 8 (a) (b) (c) (d) (e)

    Советы:
    Уравнения для большой и противоположной диагоналей равны row = col и row + col = size + 1. Решите. Что печатать выше и ниже диагонали.

  2. Напишите вызываемые программы PrintPattern2x, которые запрашивают у пользователя размер и печатают каждый из этих узоров.
    # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # (a) (b) (c) (d) (e)

8.5 Упражнения на вложенных циклах с вводом

ССЫЛКА

8.6 разрыв и продолжение — Прерывание потока контура

breakОператор прерывается и выходит из текущего (внутреннего) цикла.

continueОператор прерывает текущую итерацию и переходит к следующей итерации текущего (самого внутреннего) цикла.

break и continueэто плохие структуры. Поскольку их трудно читать и трудно следовать. Используйте их только в случае крайней необходимости.

Бесконечная петля

for ( ; ; ) { body } он известен как пустой цикл forс пустым оператором для инициализации . Тестирования и постобработки. Тело пустого for-loop будет выполняться непрерывно (бесконечный цикл). Вам нужно использовать breakоператор. Чтобы разорвать цикл.

Похожи while (true) { body }и do { body } while (true)бесконечные петли.

для (;;) { ...... в то время как (правда) { ...... делать { ...... } while (true);

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

Пример (перерыв): В следующей программе перечислены не простые числа между 2 и верхним пределом.

 публичный класс непримелист { public static void main(String[] args) { final int UPPERBOUND = 100; for (int number = 2; number) { int MaxFactor = (int)Math.sqrt(число); for (int factor = 2; factor) { if (number % factor == 0) { System.out.println(число + перерыв; 

Давайте перепишем вышеприведенную программу так. Чтобы вместо нее были перечислены все простые числа. Вызываемый booleanфлаг isPrimeиспользуется для указания того. Является ли текущий numberэлемент простым. Затем он используется для управления печатью.

 public class PrimeListWithBreak { public static void main(String[] args) { final int UPPERBOUND = 100; для (int number = 2; number) { int MaxFactor = (int)Math.sqrt(число); boolean isPrime = true; для (int factor = 2; фактор) { если (число % фактор == 0) { isPrime = false; разрывом; } если (isPrime) System.out.println(число + 

Давайте перепишем вышеприведенную программу без использования breakоператора. Вместо whileцикла with используется цикл (который управляется booleanфлагом)forbreak.

 публичный класс primeList { public static void main(String[] args) { final int UPPERBOUND = 100; для (int number = 2; number) { int MaxFactor = (int)Math.sqrt(число); boolean isPrime = true; int factor = 2; while (isPrime && factor) { если (число % фактор == 0) { ++фактор; } если (isPrime) System.out.println(число + 

Пример (продолжение):

final int UPPERBOUND = 100; int sum = 0; for (int number = 1; number) { если (число % 11 == 0) продолжить; for (int number = 1; number) { 

Пример (перерыв и продолжение): Изучите следующую программу.

 публичный класс MysterySeries { public static void main(String[] args) { int number = 1; в то время как(правда) { ++number; if ((number % 3) == 0) continue; if (number == 133) break; if ((number % 2) == 0) { number += 3; } else { число -= 3; } 
Надпись перерыв

Во вложенном цикле breakоператор прерывает внутренний цикл и переходит во внешний. Иногда возникает необходимость разорвать все петли (или несколько петель). Это неуклюже сделать с booleanпомощью флага. Но может быть легко сделано с помощью так называемой метки break. Вы можете добавить a labelв цикл в виде labelName: loop. Например,

level1: для (.....) { level2: for (.....) { for (......) { если (...) break level1; if (...) break level2: 
Надпись продолжить

Во вложенном цикле. Аналогичном breaklabeled . Вы можете использовать labeled continue для продолжения в указанный цикл. Например,

level1: for (.....) { level2: for (....) { for (......) { if (...) continue level1; if (...) continue level2: 

Опять же, маркированные breakи continueне структурированные и трудно читаемые. Используйте их только в случае крайней необходимости.

Пример (с надписью break): Предположим. Что вы ищете определенное число в 2D-массиве.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
public class TestLabeledBreak { public static void main(String[] args) { int[][] testArray = { final int MAGIC_NUMBER = 8; boolean found = false; mainLoop: for (int i = 0; i) { for (int j = 0; j) { if (testArray[i][j] == MAGIC_NUMBER) { найдено = истина; сломать mainLoop;System.out.println(

9. Операции со строками и символами

9.1 Арифметические операции С символами

Напомним, что:

  • В Java каждый charиз них представлен 16-битным номером Unicode. Например, char '0' представлен кодовым номером 48(30H), char '1'by 49(31H), char 'A'by 65(41H). char 'a' by 97(61H). Обратите внимание . Что char '0'ЭТОГО НЕТint 0, char '1'этого НЕТ int 1.
  • chars может принимать участие в арифметических операциях. А charтрактуется как его основа int(в диапазоне [0, 65535]) в арифметических операциях. Другими словами, charи intвзаимозаменяемы. char '0' ⇔ int 48, char '1' ⇔ int 49, char 'A' ⇔ int 65, char 'a' ⇔ int 97. Для примера,

    char c1 = '0'; char c2 = 'A'; char c3; System.out.println((int)c1); System.out.println((int)c2); c3 = 97; System.out.println(c3); System.out.println((char)97); 
  • В арифметических операциях charbyte, и short) сначала преобразуется в int. В Java арифметические операции выполняются только вint,long,float, или double; НЕ вbyte,short, и char.
  • Следовательно, char ⊕ char ⇒ int ⊕ int ⇒ int, где обозначает двоичную арифметическую операцию (такую как+, -,*, /и %). Возможно, вам придется явно вернуть результирующую intобратно char. Для примера,
    char c1 = '0'; char c2 = 'A'; char c3; //c3 = c1 + c2; c3 = (char)(c1 + c2); System.out.println(c3); System.out.println(c1 + c2); System.out.println((char)(c1 + c2)); 
  • Похожие, char ⊕ int ⇒ int ⊕ int ⇒ int. Возможно, вам придется явно вернуть результирующую intобратно char. Для примера,
    char c1 = '0'; char c2 = 'A'; char c3; //c3 = c1 + 5; c3 = (char)(c1 + 5); System.out.println(c3); System.out.println(c1 + 5); for (int codeNum = 'a'; codeNum) { 
  • Однако для составных операторов (таких как+=,-=,*=,/=,%=) оценка выполняется в int, но результат автоматически возвращается в LHS. Для примера,
    char c4 = '0'; c4 += 5; System.out.println(c4); 
  • Для инкремента (++) и декремента (--) из charbyte, и short) нет никакого продвижения к int. Для примера,
     for (char c = '0'; c 

9.2 Преобразование char в int

Вы можете преобразовать char '0'в '9'int 0в 9, вычитая charс основанием'0', например,'8' - '0' ⇒ 8.

То есть предположимc, что есть charпромежуток между '0'и '9', (c - '0')соответствующее int 09.

Следующая программа показывает . Как преобразовать шестнадцатеричный символ (0-9A-Fили a-f) в его десятичный эквивалент (0-15), вычитая соответствующую базу char.

 char hexChar = 'a'; int dec; dec = hexChar - '0'; dec = hexChar - 'A' + 10; 

9.3 Строковые Операции

Наиболее часто используемые Stringметоды следующие: Предположим, чтоstr,str1, str2являются Stringпеременными:

  • str.length(): верните длину файла str.
  • str.charAt(int index): верните ключ charв исходное indexположение str. Обратите внимание на то . Что indexначинается с 0и до str.length()-1.
  • str1.equals(str2): для сравнения содержания str1и.str2 Обратите внимание. Что вы не можете использовать "str1 == str2"для сравнения два Strings. Это происходит потому. Что ==Stringне является примитивным типом.

Для примера,

String str = System.out.println(str.length()); System.out.println(str.charAt(2)); System.out.println(str.charAt(5));   Строка anotherStr = System.out.println(str.equals(anotherStr)); System.out.println(str.equalsIgnoreCase(anotherStr)); System.out.println(anotherStr.equals(str)); System.out.println(anotherStr.equalsIgnoreCase(str)); 

Проверить все доступные методы String, открытые для JDK документация ⇒ выберите java.basejava.base пакетовjava.langStringhttps://docs.oracle.com/javase/10/docs/api/java/lang/String.html для JDK 10).

Для примера,

String str = System.out.println(str.length()); System.out.println(str.charAt(2)); System.out.println(str.substring(0, 3)); System.out.println(str.indexOf('a')); System.out.println(str.lastIndexOf('a')); System.out.println(str.EndsWith( System.out.println(str.toUpperCase()); System.out.println(str.toLowerCase()); 

9.4 Преобразование строки в примитив

String to int/byte/short/long

Вы можете использовать встроенные методы JDK Integer.parseInt(anIntStr)для преобразования Stringсодержащего допустимый целочисленный литерал (например, 1234int(например, 1234). Среда выполнения запускает aNumberFormatException, если входная строка не содержит допустимого целочисленного литерала (например,abcНапример,

Строка inStr = "5566"; int number = Integer.parseInt(inStr); //number = Integer.parseInt("abc"); 

Аналогично, вы можете использовать методы Byte.parseByte(aByteStr), Short.parseShort(aShortStr), Long.parseLong(aLongStr)чтобы преобразовать aString, содержащий допустимый byteshortили longлитерал . В примитивный тип.

String to double/float

Вы можете использовать Double.parseDouble(aDoubleStr)или Float.parseFloat(aFloatStr)для преобразования a String(содержащего литерал с плавающей запятой) в doubleили float, например

Строка inStr = float aFloat = Float.parseFloat(inStr); double aDouble = Double.parseDouble( aDouble = Double.parseDouble(  //aDouble = Double.parseDouble( 
Строка в символ

Вы можете использовать aStr.charAt(index)для извлечения отдельного символа из a String, где indexначинается at 0и до aStr.length()-1, например,

 Строка msg = char msgChar; for (int idx = 0; idx) { msgChar = msg.charAt(idx); 
String to boolean

Вы можете использовать метод Boolean.parseBoolean(aBooleanStr)для преобразования строки truefalseboolean trueили false, например,

Строка boolStr = boolean done = Boolean.parseBoolean(boolStr); boolean valid = Boolean.parseBoolean(

9.5 Преобразование примитива в строку

Чтобы преобразовать примитив в a String, вы можете:

  1. Используйте+оператор » для объединения примитива с пустым String "".
  2. Используйте встроенные методы JDK String.valueOf(aPrimitve), которые применимы ко всем примитивам.
  3. Используйте toString()методы соответствующего класса-оболочки. Такие какInteger.toString(anInt),Double.toString(aDouble),Character.toString(aChar)Boolean.toString(aBoolean), и т. Д.

Для примера,

 Строка str1 = 123 + String str2 = 12.34 + String str3 = 'c' + String str4 = true + String str5 = String.valueOf(12345); String str6 = String.valueof(true); String str7 = String.valueOf(55.66); String str8 = Integer.toString(1234); Строка str9 = Double.toString(1.23); Строка str10 = Символ.toString('z'); 

9.6 Форматирование строкиs — String.format()

Напомним. Что вы можете использовать printf()его для создания форматированной строки и отправки ее на консоль отображения, например,

System.out.printf(

Существует аналогичная функция, String.format()которая возвращает форматированную строку вместо отправки на консоль, например,

String str = String.format(

String.format() имеет ту же форму, printf()что и .

9.7 Пример кода: Обратная строка

Следующая программа запрашивает у пользователя строку и выводит входную строку в обратном порядке. Для примера,

Введите строку: abcdefg Обратное: gfedcba
импорт java.util.Сканер; публичный класс ReverseString { public static void main(String[] args) { String inStr; int inStrLen; Scanner in = новый сканер(System.in); System.out.print(inStr = in.next(); inStrLen = inStr.length(); in.close(); System.out.print(

9.8 Пример кода: Проверка Двоичной Строки

Следующая программа запрашивает у пользователя строку и проверяет. Является ли вход допустимой двоичной строкой. Состоящей '0''1'только из и. Например,

Введите двоичную строку: 1011000 Введите двоичную строку: 10001900 
Версия 1: С логическим флагом
импорт java.util.Сканер; открытый класс ValidateBinString { public static void main(String[] args) { String inStr; int inStrLen; char inChar; boolean isValid; Scanner in = новый сканер(System.in); System.out.print(inStr = in.next(); inStrLen = inStr.length(); in.close(); isValid = true; для (int inCharIdx = 0; inCharIdx) { inChar = inStr.charAt(inCharIdx); if (!(inChar == '0' || inChar == '1')) { isValid = false; прервать; 
Версия 2
импорт java.util.Сканер; открытый класс ValidateBinStringV2 { public static void main(String[] args) { String inStr; int inStrLen; char inChar; Scanner in = новый сканер(System.in); System.out.print(inStr = in.next(); inStrLen = inStr.length(); in.close(); for (int inCharIdx = 0; inCharIdx) { inChar = inStr.charAt(inCharIdx); if (!(inChar == '0' || inChar == '1')) { System.out.println(return; 

Эта версия, хотя и короче. Труднее читается и труднее поддерживается.

9.9 Пример кода: Двоичный — десятичный (Bin2Dec)

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

Введите двоичную строку: 10001001 Эквивалентное десятичное число для 
импорт java.util.Сканер; публичный класс Bin2Dec { public static void main(String[] args) { String binStr; int binStrLen; int dec = 0; char binChar; Scanner in = новый сканер(System.in); System.out.print(binStr = in.next(); binStrLen = binStr.length(); in.close(); for (int exp = 0; exp) { binChar = binStr.charAt(binStrLen - 1 - exp); если (binChar == '1') { dec += (int)Math.pow(2, exp); } еще { System.out.println(return; 

Примечания:

  1. Формула преобразования:
    binStr = bn-1bn-2.... b2b1b0 hi0-наименее значимый бит dec = bn-1×2n-1 + bn-2×2n-2 + ... + b2×22 + b1×21 + b0×20
  2. Мы используемbinStr.charAt(idx), чтобы извлечь каждого человека charиз binStr. idxНачинается с нуля и увеличивается слева направо. С другой стороны, число экспонент увеличивается справа налево, как показано в следующем примере:
    binStr : 1 0 1 1 1 0 0 1 charAt(idx) : 0 1 2 3 4 5 6 7 (idx увеличивается слева) Math.pow(2, exp) : 7 6 5 4 3 2 1 0 (exp увеличивается справа) binStr.length() = 8 idx + exp = binStr.length() - 1
  3. Этот код использует expв качестве индекса цикла и вычисляет idxдля charAt()использования отношения idx + exp = binStr.length() - 1. Вы также можете использовать индекс idxas the loop (см. Следующий пример).
  4. Мы используем встроенную функцию Math.pow(x, y)для вычисления показателя степени. Который принимает два doubles и возвращает a double. Нам нужно явно отбросить результирующую doubleобратно в intfor dec.
  5. Есть 3 случая для обработки: '1'(добавить к dec), '0'(допустимо. Но ничего не делать для умножения на 0) и другие (ошибка). Мы можем написать вложенное-если следующим образом, но это труднее читать:
    if (binChar == '1') { dec += (int)Math.pow(2, exp); } else if (binChar != '0') { System.out.println(return; } 
  6. Вы можете использовать ScannernextInt(int radix)этот метод для чтения intв нужном radixместе . Попробуйте прочитать двоичное число (радиус 2) и вывести его десятичный эквивалент. Например,
    number = in.nextInt(2); System.out.println(номер); 

9.10 Пример кода: Преобразование шестнадцатеричного числа в десятичное (Hex2Dec)

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

Введите шестнадцатеричную строку: 10aB Эквивалентное десятичное число для 
импорт java.util.Сканер; публичный класс Hex2Dec { public static void main(String[] args) { String hexStr; int hexStrLen; int dec = 0; Scanner in = новый сканер(System.in); System.out.print(hexStr = in.next(); hexStrLen = hexStr.length(); in.close(); for (int charIdx = 0; charIdx); int expFactor = (int)Math.pow(16, hexStrLen - 1 - charIdx); if (hexChar == '0') { dec += (hexChar - '0') * expFactor; 

Примечания:

  1. Формула преобразования:
    hexStr = hn-1hn-2....h2b1h0 hi0-наименее значимый разряд dec = hn-1×16n-1 + hn-2×16n-2 + ... + h2×162 + h1×161 + h0×160
  2. В этом примере мы используем charIdxиндекс цикла в качестве индекса цикла и вычисляем показатель степени через отношение charIdx + exp = hexStr.length() - 1(см. иллюстрацию в предыдущем примере).
  3. Вы могли бы написать большой switchиз 23 cases (0-9, A-F, a-f, и других). Но обратите внимание. Как они сводятся к 5 случаям.
    1. hexChar '1'Чтобы преобразовать '9'int 19значение в значение в . Мы вычитаем hexCharего по основанию '0'.
    2. Аналогично, чтобы преобразовать hexChar 'a'to 'f'(или 'A'to 'F') в int 10to 15, мы вычитаем the hexCharна основание 'a'(или 'A') и прибавляем 10.
  4. Вы можете использовать str.toLowerCase()его для преобразования входной строки в нижний регистр. Чтобы еще больше уменьшить количество падежей. Но вам нужно сохранить оригинал Stringдля вывода в этом примере (в противном случае вы могли бы использовать in.next().toLowerCase()его напрямую).

9.11 Упражнения по работе со строками и символами

ССЫЛКА

10. Массивы

Предположим. Что вы хотите найти среднее значение оценок для класса из 30 учеников, вы, конечно же. Не хотите создавать 30 переменных:mark1,mark2,…,mark30. Вместо этого Вы можете использовать одну переменную. Называемую массивом, с 30 элементами (или элементами).

Массив — это упорядоченная совокупность элементов одного типа, обозначенных парой квадратных скобок [ ]. Чтобы использовать массив. Вам необходимо:

  1. Объявите массив с именем и типом. Используйте имя массива во множественном числе. Например, marks, rows, numbers. Все элементы массива принадлежат к одному типу.
  2. Выделите массив с помощью newоператора или с помощью инициализации, например,

    int[] marks; int marks[]; marks = new int[5]; int[] factors = new int[20]; 

Когда массив строится с помощью newоператора, все элементы инициализируются до их значения по умолчанию, например, 0для int, 0.0для double, falseдля booleanи nullдля объектов. [В отличие от C/C++. Который НЕ инициализирует содержимое массива.]

Когда массив объявлен. Но не выделен. Он имеет специальное вызываемое значение null.

10.1 Индекс массива

Вы можете ссылаться на элемент массива с помощью индекса (или индекса), заключенного в квадратную скобку [ ]. Индекс массива Java начинается с нуля (0). Например, предположим. Что marksэто intмассив из 5 элементов. То 5 элементов: marks[0], marks[1], marks[2],marks[3], и marks[4].

int[] marks = new int[5]; метки[0] = 95; marks[1] = 85; marks[2] = 77; marks[3] = 69; marks[4] = 66; System.out.println(marks[0]); System.out.println(marks[3] + marks[4]);

10.2 Длина массива

Чтобы создать массив. Необходимо знать длину (или размер) массива заранее. И выделять соответственно. Как только массив создан. Его длина фиксирована и не может быть изменена во время выполнения. Иногда бывает трудно определить длину массива (например. Сколько учеников?). Тем не менее. Вам нужно оценить длину и выделить верхнюю границу. Предположим. Что вы установили длину 30 (для класса студентов) и в нем есть 31 студент. Вам нужно выделить новый массив (длиной 31). Скопировать старый массив в новый массив и удалить старый массив. Другими словами. Длина массива не может динамически регулироваться во время выполнения. This is probably the major drawback of using an array. (There are other structures that can be dynamically adjusted.)

In Java, the length of array is kept in an associated variable called length and can be retrieved using «arrayName.length«, e.g.,

int[] factors = new int[5]; int numFactors = factors.length; 

массив

The index of an array is between 0 and arrayName.length - 1.

Unlike languages like C/C++. Java performs array index-bound check at the runtime. In other words. For each reference to an array element. The index is checked against the array’s length. If the index is outside the range of [0, arrayName.length-1], Java Runtime will signal an exception called ArrayIndexOutOfBoundException. It is important to note that checking array index-bound consumes computation power. Which inevitably slows down the processing. However, the benefits gained in terms of good software engineering out-weight the slow down in speed.

10.3  Array and Loop

Arrays works hand-in-hand with loops. You can process all the elements of an array via a loop. For example,

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
 public class MeanSDArray { public static void main(String[] args) { int[] marks = {74, 43, 58, 60, 90, 64, 70}; int sum = 0; int sumSq = 0; double mean. StdDev; for (int i = 0; i 

10.4  Enhanced for-loop (or «for-each» Loop) (JDK 5)

JDK 5 introduces a new loop syntax known as enhanced for-loop (or for-each loop) to facilitate processing of arrays and collections. It takes the following syntax:

Syntax Example
for (type item : anArray) { body ; }   
int[] numbers = {8, 2, 6, 4, 3}; int sum = 0, sumSq = 0; for (int number : numbers) { sum += number; sumSq += number * number; } System.out.println("The sum is: " + sum); System.out.println("The square sum is: " + sumSq);

This loop shall be read as «for each element in the array…». The loop executes once for each element in the array. With the element’s value copied into the declared variable. The for-each loop is handy to transverse all the elements of an array. It requires fewer lines of code. Eliminates the loop counter and the array index. And is easier to read. However, for array of primitive types (e.g.. Array of ints), it can read the elements only. And cannot modify the array’s contents. This is because each element’s value is copied into the loop’s variable. Instead of working on its original copy.

In many situations. You merely want to transverse thru the array and read each of the elements. For these cases. Enhanced for-loop is preferred and recommended over other loop constructs.

10.5  Code Example: Read and Print Array

The following program prompts user for the length and all the elements of an array, and print the array in the form of [a0, a1, ..., an]. For examples,

Enter the number of items: 5 Enter the value of all items (separated by space): 7 9 1 6 2 The values are: [7, 9, 1, 6, 2]
import java.util.Scanner; public class ReadPrintArray { public static void main(String[] args) { final int NUM_ITEMS; int[] items; Scanner in = new Scanner(System.in); System.out.print("Enter the number of items: "); NUM_ITEMS = in.nextInt(); items = new int[NUM_ITEMS]; if (items.length > 0) { System.out.print("Enter the value of all items (separated by space): "); for (int i = 0; i 
Arrays.toString() (JDK 5)

JDK 5 provides an built-in methods called Arrays.toString(anArray), which returns a String in the form [a0, a1, ..., an]. You need to import java.util.Arrays. For examples,

import java.util.Arrays; public class TestArrayToString { public static void main(String[] args) { int[] a1 = {6 ,1, 3, 4, 5}; int[] a2 = {}; double[] a3 = new double[1]; System.out.println(Arrays.toString(a1)); System.out.println(Arrays.toString(a2)); System.out.println(Arrays.toString(a3)); a3[0] = 2.2; System.out.println(Arrays.toString(a3)); } }

10.6  Code Example: Horizontal and Vertical Histograms

The following program prompts user for the number of students. And the grade of each student. It then print the histogram. In horizontal and vertical forms. As follows:

Enter the grade for student 1: 98 Enter the grade for student 2: 100 Enter the grade for student 3: 9 Enter the grade for student 4: 3 Enter the grade for student 5: 56 Enter the grade for student 6: 58 Enter the grade for student 7: 59 Enter the grade for student 8: 87 0- 9: ** 10- 19: 20- 29: 30- 39: 40- 49: 50- 59: *** 60- 69: 70- 79: 80- 89: * 90-100: ** * * * * * * * * 0-9 10-19 20-29 30-39 40-49 50-59 60-69 70-79 80-89 90-100
import java.util.Scanner; import java.util.Arrays; public class GradesHistograms { public static void main(String[] args) { int numStudents; int[] grades; int[] bins = new int[10]; Scanner in = new Scanner(System.in); System.out.print("Enter the number of students: "); numStudents = in.nextInt(); grades = new int[numStudents]; for (int i = 0; i 0; --level) { for (int binIdx = 0; binIdx = level) { System.out.print(" * "); } else { System.out.print(" "); } } System.out.println(); } for (int binIdx = 0; binIdx 
Notes:
  1. We use two arrays in this exercise. One for storing the grades of the students (of the length numStudents) and the other to storing the histogram counts (of length 10).
  2. We use a 10-element int arrays called bins, to keep the histogram counts for grades of [0, 9], [10, 19], ..., [90, 100]. Take note that there are 101 grades between [0, 100], and the last bin has 11 grades (instead of 10 for the rest). The bins's index is grade/10, except grade of 100.

10.7  Code Example: Hexadecimal to Binary (Hex2Bin)

The following program prompts user for a hexadecimal string and convert it to its binary equivalence. For example,

Enter a Hexadecimal string: 1bE3 The equivalent binary for "1bE3" is "0001101111100011"
import java.util.Scanner; public class Hex2Bin { public static void main(String[] args) { String hexStr; int hexStrLen; char hexChar; String binStr =""; final String[] BIN_STRS = {"0000", "0001". "0010", "0011". "0100", "0101". "0110", "0111". "1000", "1001". "1010", "1011". "1100", "1101". "1110", "1111"}; Scanner in = new Scanner(System.in); System.out.print("Enter a Hexadecimal string: "); hexStr = in.next(); hexStrLen = hexStr.length(); in.close(); for (int charIdx = 0; charIdx = '0' && hexChar = 'a' && hexChar = 'A' && hexChar 
Notes
  1. We keep the binary string corresponding to hex digit '0' to 'F' in an array with indexes of 0-15, used as look-up table.
  2. We extract each hexChar, find its array index (0-15), and retrieve the binary string from the array based on the index.
    1. To convert hexChar '1' to '9' to int 1 to 9, we subtract the hexChar by the base '0'.
    2. Similarly, to convert hexChar 'a' to 'f' (or 'A' to 'F') to int 10 to 15, we subtract the hexChar by the base 'a' (or 'A') and add 10.

10.8  Code Example: Decimal to Hexadecimal (Dec2Hex)

The following program prompts user for an integer. Reads as int, and prints its hexadecimal equivalent. For example,

Enter a decimal number: 1234 The equivalent hexadecimal number is 4D2
import java.util.Scanner; public class Dec2Hex { public static void main(String[] args) { int dec; String hexStr = ""; int radix = 16; final char[] HEX_CHARS = {'0','1','2','3'. '4','5','6','7'. '8','9','A','B'. 'C','D','E','F'}; Scanner in = new Scanner(System.in); System.out.print("Enter a decimal number: "); dec = in.nextInt(); in.close(); while (dec > 0) { int hexDigit = dec % radix; hexStr = HEX_CHARS[hexDigit] + hexStr; dec = dec / radix; } System.out.println("The equivalent hexadecimal number is " + hexStr); } }
Notes
  1. We use modulus/divide algorithm to get the hex digits (0-15) in reserve order. See "Number System Conversion".
  2. We look up the hex digit '0'-'F' from an array using index 0-15.

10.9  Exercises on Arrays

LINK

10.10  Multi-Dimensional Array

In Java. You can declare an array of arrays. For examples:

int grid[][] = new int[12][8]; grid[0][0] = 8; grid[1][1] = 5; System.out.println(grid.length); System.out.println(grid[0].length); System.out.println(grid[11].length); 

In the above example, grid is an array of 12 elements. Each of the elements (grid[0] to grid[11]) is an 8-element int array. In other words, grid is a "12-element array" of "8-element int arrays". Hence, grid.length gives 12 and grid[0].length gives 8.

public class Array2DTest { public static void main(String[] args) { int[][] grid = new int[12][8]; final int NUM_ROWS = grid.length; final int NUM_COLS = grid[0].length; for (int row = 0; row Array_MultiDimensional.png

To be precise. Java does not support multi-dimensional array directly. That is, it does not support syntax like grid[3, 2] like some languages. Furthermore. It is possible that the arrays in an array-of-arrays have different length.

Take note that the right way to view the "array of arrays" is as shown. Instead of treating it as a 2D table. Even if all the arrays have the same length.

For example,

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
public class Array2DWithDifferentLength { public static void main(String[] args) { int[][] grid = { {1, 2}, {3, 4, 5}, {6, 7, 8, 9} }; for (int y = 0; y 

11.  Methods (Functions)

11.1  Why Methods?

At times, a certain portion of code has to be used many times. Instead of re-writing the code many times. It is better to put them into a «subroutine». And «call» this «subroutine» many time — for ease of maintenance and understanding. Subroutine is called method (in Java) or function (in C/C++).

The benefits of using methods are:

  1. Divide and conquer: Construct the program from simple. Small pieces or components. Modularize the program into self-contained tasks.
  2. Avoid repeating code: It is easy to copy and paste. But hard to maintain and synchronize all the copies.
  3. Software Reuse: You can reuse the methods in other programs. By packaging them into library code (or API).

11.2  Using Methods

Two parties are involved in using a method: a caller, who calls (or invokes) the method. And the method called.

The process is:

  1. The caller invokes a method and passes arguments to the method.
  2. The method:
    1. receives the arguments passed by the caller,
    2. performs the programmed operations defined in the method’s body, and
    3. returns a result back to the caller.
  3. The caller receives the result. And continue its operations.

Example: Suppose that we need to evaluate the area of a circle many times. It is better to write a method called getArea(), and re-use it when needed.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
public class EgMethodGetArea { public static void main(String[] args) { double r = 1.1, area. Area2; area = getArea(r); System.out.println("area is " + area); area2 = getArea(2.2); System.out.println("area 2 is " + area2); System.out.println("area 3 is " + getArea(3.3)); } public static double getArea(double radius) { return radius * radius * Math.PI; } }

Метод.png

The expected outputs are:

area is 3.8013271108436504 area 2 is 15.205308443374602 area 3 is 34.21194399759284

In the above example. A reusable method called getArea() is defined. Which receives an argument in double from the caller. Performs the calculation. And return a double result to the caller. In the main(), we invoke getArea() methods thrice. Each time with a different parameter.

Take note that there is a transfer of control from the caller to the method called. And from the method back to the caller. As illustrated.

Метод.png

Tracing Method Invocation

You can trace method operations under Eclipse/NetBeans (Refer to the the Eclipse/NetBeans How-to article):

  • Step Over: Treat the method call as one single step.
  • Step Into: Step into the method. So that you can trace the operations of the method.
  • Step Out: Complete the current method and return to the caller.
  • Set «Breakpoints» inside the method. And «resume» running to the next breakpoint.
Method Definition Syntax

The syntax for method definition is as follows:

public static returnValueType methodName(arg-1-type arg-1, arg-2-type arg-2,... ) { body ; }
 public static double getArea(double radius) { return radius * radius * Math.PI; } public static int max(int number1, int number2) { if (number1 > number2) { return number1; } else { return number2; } }

Take note that you need to specify the type of the arguments and the return value in method definition.

Calling Methods

To call a method. Simply use methodName(arguments). For examples. To call the above methods:

 double area1 = getArea(1.1); double r2 = 2.2; double area2 = getArea(r2); double r3 = 3.3; System.out.println("Area is: " + area(r3)); int result1 = max(5, 8); int i1 = 7, i2 = 9; int result2 = max(i1, i2); System.out.println("Max is: " + max(15, 16));

Take note that you need to specify the type in the method definition. But not during invocation.

Method Naming Convention

A method’s name shall be a verb or verb phrase (action). Comprising one or more words. The first word is in lowercase. While the rest are initial-capitalized (called camel-case). For example, getArea(), setRadius(), moveDown(), isPrime(), etc.

Another Example:

 public class EgMinMaxMethod { public static void main(String[] args) { int a = 6, b = 9, max. Min; max = max(a. B); min = min(a, b); System.out.println(max + "," + min); System.out.println(max(5, 8)); System.out.println(min(5, 8)); } public static int max(int number1, int number2) { if (number1 > number2) { return number1; } else { return number2; } } public static int min(int number1, int number2) { return (number1 

11.3  The "return" statement

Inside the method body. You could use a return statement to return a value (of the returnValueType declared in the method's signature) to return a value back to the caller. The syntax is:

return aReturnValue; return; 

11.4  The "void" Return-Type

Suppose that you need a method to perform certain actions (e.g.. Printing) without a need to return a value to the caller. You can declare its return-value type as void. In the method's body. You could use a "return;" statement without a return value to return control to the caller. In this case, the return statement is optional. If there is no return statement. The entire body will be executed. And control returns to the caller at the end of the body.

Notice that main() is a method with a return-value type of void. main() is called by the Java runtime. Perform the actions defined in the body. And return nothing back to the Java runtime.

11.5  Actual Parameters vs. Formal Parameters

Recall that a method receives arguments from its caller. Performs the actions defined in the method's body. And return a value (or nothing) to the caller.

In the above example. The variable (double radius) declared in the signature of getArea(double radius) is known as formal parameter. Its scope is within the method's body. When the method is invoked by a caller. The caller must supply so-called actual parameters or arguments, whose value is then used for the actual computation. For example. When the method is invoked via "area1=getArea(radius1)", radius1 is the actual parameter. With a value of 1.1.

11.6  Code Example: Magic Number

The following program contains a boolean method called isMagic(int number), which returns true if the given number contains the digit 8, e.g., 18, 108, and 1288. The signature of the method is:

public static boolean isMagic(int number);

It also provides the main() method to test the isMagic(). For example,

Enter a positive integer: 1288 1288 is a magic number Enter a positive integer: 1234567 1234567 is not a magic number
import java.util.Scanner; public class MagicNumber { public static void main(String[] args) { int number; Scanner in = new Scanner(System.in); System.out.print("Enter a positive integer: "); number = in.nextInt(); if (isMagic(number)) { System.out.println(number + " is a magic number"); } else { System.out.println(number + " is not a magic number"); } in.close(); } public static boolean isMagic(int number) { boolean isMagic = false; while (number > 0) { int digit = number % 10; if (digit == 8) { isMagic = true; break; } number /= 10; } return isMagic; } }

Take note of the proper documentation comment for the method.

11.7  Code Example: int Array Methods

The following program contains various method for int array with signatures as follows:

public static void print(int[] array); public static int min(int[] array); public static int sum(int[] array); public static double average(int[] array); 

It also contains the main() method to test all the methods. For example,

Enter the number of items: 5 Enter the value of all items (separated by space): 8 1 3 9 4 The values are: [8, 1, 3, 9, 4] The min is: 1 The sum is: 25 The average (rounded to 2 decimal places) is: 5.00
import java.util.Scanner; public class IntArrayMethodsTest { public static void main(String[] args) { final int NUM_ITEMS; int[] items; Scanner in = new Scanner(System.in); System.out.print("Enter the number of items: "); NUM_ITEMS = in.nextInt(); items = new int[NUM_ITEMS]; if (items.length > 0) { System.out.print("Enter the value of all items (separated by space): "); for (int i = 0; i print(int[] array) { System.out.print("["); for (int i = 0; i min(int[] array) { int min = array[0]; for (int i = 1; i sum(int[] array) { int sum = 0; for (int item: array) sum += item; return sum; } public static double average(int[] array) { return (double)(sum(array)) / array.length; } }

11.8  Pass-by-Value for Primitive-Type Parameters

In Java. When an argument of primitive type is pass into a method, a copy is created and passed into the method. The invoked method works on the cloned copy, and cannot modify the original copy. This is known as pass-by-value.

For example,

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
public class PassByValueTest { public static void main(String[] args) { int number = 8, result; System.out.println("In caller. Before calling the method, number is: " + number); result = increment(number); System.out.println("In caller. After calling the method, number is: " + number); System.out.println("The result is " + result); } public static int increment(int number) { System.out.println("Inside method. Before operation. Number is " + number); ++number; System.out.println("Inside method. After operation. Number is " + number); return number; } }

Notes:

  1. Although there is a variable called number in both the main() and increment() method. There are two distinct copies — one available in main() and another available in increment() — happen to have the same name. You can change the name of either one. Without affecting the program.

11.9  Pass-by-Reference for Arrays and Objects

As mentioned. For primitive-type parameters. A cloned copy is made and passed into the method. Hence, the method cannot modify the values in the caller. It is known as pass-by-value.

For arrays (and objects — to be described in the later chapter). The array reference is passed into the method and the method can modify the contents of array’s elements. It is known as pass-by-reference. For example,

import java.util.Arrays; public class PassByReferenceTest { public static void main(String[] args) { int[] testArray = {9, 5, 6, 1, 4}; System.out.println("In caller. Before calling the method, array is: " + Arrays.toString(testArray)); increment(testArray); System.out.println("In caller. After calling the method, array is: " + Arrays.toString(testArray)); } public static void increment(int[] array) { System.out.println("Inside method. Before operation, array is " + Arrays.toString(array)); for (int i = 0; i 

11.10  Varargs - Method with Variable Number of Formal Arguments (JDK 5)

Before JDK 5, a method has to be declared with a fixed number of formal arguments. C-like printf(), which take a variable number of argument, cannot not be implemented. Although you can use an array for passing a variable number of arguments. It is not neat and requires some programming efforts.

JDK 5 introduces variable arguments (or varargs) and a new syntax "Type...". For example,

public PrintWriter printf(String format. Object... args) public PrintWriter printf(Local l. String format. Object... args)

Varargs can be used only for the last argument. The three dots (...) indicate that the last argument may be passed as an array or as a sequence of comma-separated arguments. The compiler automatically packs the varargs into an array. You could then retrieve and process each of these arguments inside the method's body as an array. It is possible to pass varargs as an array. Because Java maintains the length of the array in an associated variable length.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
public class VarargsTest { public static void doSomething(String... strs) { System.out.print("Arguments are: "); for (String str : strs) { System.out.print(str + ", "); } System.out.println(); } public static void doSomething(String s1, String s2) { System.out.println("Overloaded version with 2 args: " + s1 + ", " + s2); } public static void main(String... args) { doSomething("Hello", "world". "again", "and". "again"); doSomething("Hello", "world"); String[] strs = {"apple". "orange"}; doSomething(strs); } }

Notes:

11.11  Implicit Type-Casting for Method’s Parameters

A method that takes a double parameter can accept any numeric primitive type. Such as int or float. This is because implicit type-casting is carried out. However, a method that take a int parameter cannot accept a double value. This is because the implicit type-casting is always a widening conversion which prevents loss of precision. An explicit type-cast is required for narrowing conversion. Read «Type-Casting» on the conversion rules.

11.12  Method Overloading

In Java. A method (of a particular method name) can have more than one versions. Each version operates on different set of parameters — known as method overloading. The versions shall be differentiated by the numbers, types. Or orders of the parameters.

Example 1
 public class AverageMethodOverloading { public static void main(String[] args) { System.out.println(average(8, 6)); System.out.println(average(8, 6, 9)); System.out.println(average(8.1, 6.1)); System.out.println(average(8, 6.1)); //average(1, 2, 3, 4) } public static int average(int n1, int n2) { System.out.println("version 1"); return (n1 + n2)/2; } public static int average(int n1, int n2, int n3) { System.out.println("version 2"); return (n1 + n2 + n3)/3; } public static double average(double n1, double n2) { System.out.println("version 3"); return (n1 + n2)/2.0; } }

The expected outputs are:

version 1 7 version 2 7 version 3 7.1 version 3 7.05
Example 2: Arrays

Suppose you need a method to compute the sum of the elements for int[], short[], float[] and double[], you need to write all overloaded versions — there is no shortcut.

 public class SumArrayMethodOverloading { public static void main(String[] args) { int[] a1 = {9, 1, 2, 6, 5}; System.out.println(sum(a1)); double[] a2 = {1.1, 2.2, 3.3}; System.out.println(sum(a2)); float[] a3 = {1.1f, 2.2f, 3.3f}; //System.out.println(sum(a3)); } public static int sum(int[] array) { System.out.println("version 1"); int sum = 0; for (int item : array) sum += item; return sum; } public static double sum(double[] array) { System.out.println("version 2"); double sum = 0.0; for (double item : array) sum += item; return sum; } }

Notes:

  1. Unlike primitives. Where int would be autocasted to double during method invocation, int[] is not casted to double[].
  2. To handle all the 7 primitive number type arrays. You need to write 7 overloaded versions to handle each array types!

11.13  «boolean» Methods

A boolean method returns a boolean value to the caller.

Suppose that we wish to write a method called isOdd() to check if a given number is odd.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
 public class BooleanMethodTest { public static boolean isOdd(int number) { if (number % 2 == 1) { return true; } else { return false; } } public static void main(String[] args) { System.out.println(isOdd(5)); System.out.println(isOdd(6)); System.out.println(isOdd(-5)); } }

This seemingly correct code produces false for -5, because -5%2 is -1 instead of 1. You may rewrite the condition:

public static boolean isOdd(int number) { if (number % 2 == 0) { return false; } else { return true; } }

The above produces the correct answer. But is poor. For boolean method, you can simply return the resultant boolean value of the comparison, instead of using a conditional statement, as follow:

public static boolean isEven(int number) { return (number % 2 == 0); } public static boolean isOdd(int number) { return !(number % 2 == 0); }

11.14  Mathematical Methods

JDK provides many common-used Mathematical methods in a class called Math. The signatures of some of these methods are:

double Math.pow(double x. Double y) double Math.sqrt(double x) double Math.random() double Math.sin() double Math.cos()

The Math class also provide two constants:

Math.PI Math.E 

To check all the available methods. Open JDK API documentation ⇒ select module «java.base» ⇒ select package «java.lang» ⇒ select class «Math» ⇒ choose method (@ https://docs.oracle.com/javase/10/docs/api/java/lang/Math.html for JDK 10).

For examples,

int secretNumber = (int)Math.random()*100;   double radius = 5.5; double area = radius*radius*Math.PI; area = Math.pow(radius, 2)*Math.PI;   int x1 = 1, y1 = 1, x2 = 2, y2 = 2; double distance = Math.sqrt((x2-x1)*(x2-x1) + (y2-y1)*(y2-y1)); int dx = x2 - x1; int dy = y2 - y1; distance = Math.sqrt(dx*dx + dy*dy); 

11.15  Exercises on Methods

LINK

12.  Command-Line Arguments

Java’s main(String[] args) method takes an argument: String[] args, i.e., a String array named args. This is known as «command-line arguments». Which corresponds to the augments provided by the user when the java program is invoked. For example. A Java program called Arithmetic could be invoked with additional command-line arguments as follows (in a «cmd» shell):

java Arithmetic 12 3456 +

Each argument, i.e., "12", "3456" and "+", is a String. Java runtime packs all the arguments into a String array and passes into the main() method as args. For this example, args has the following properties:

args = {"12". "3456". "+"} args.length = 3 args[0] = "12" args[1] = "3456" args[2] = "+" args[0].length() = 2 args[1].length() = 4 args[2].length() = 1

12.1  Code Example: Arithmetic

The program Arithmetic reads three parameters form the command-line. Two integers and an arithmetic operator ('+', '-', '*', or '/'), and performs the arithmetic operation accordingly. For example,

java Arithmetic 3 2 + 3+2=5 java Arithmetic 3 2 - 3-2=1 java Arithmetic 3 2 / 3/2=1
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
public class Arithmetic { public static void main (String[] args) { int operand1, operand2; char theOperator; operand1 = Integer.parseInt(args[0]); operand2 = Integer.parseInt(args[1]); theOperator = args[2].charAt(0); System.out.print(args[0] + args[2] + args[1] + "="); switch(theOperator) { case ('+'): System.out.println(operand1 + operand2); break; case ('-'): System.out.println(operand1 - operand2); break; case ('*'): System.out.println(operand1 * operand2); break; case ('/'): System.out.println(operand1 / operand2); break; default: System.out.printf("%nError: Invalid operator!"); } } }

12.2  Exercises on Command-Line Arguments

LINK

13.  (Advanced) Bitwise Operations

13.1  Bitwise Logical Operations

Bitwise operators perform operations on one or two operands on a bit-by-bit basis, as follows. In descending order of precedences.

Operator Mode Usage Description Example
~ Unary ~x Bitwise NOT (inversion)  
& Binary x & y Bitwise AND  
| Binary x | y Bitwise OR  
^ Binary x ^ y Bitwise XOR  
Example
1 2 3 4 5 6 7 8 9 10 11 12
public class TestBitwiseOp { public static void main(String[] args) { int x = 0xAAAA_5555; int y = 0x5555_1111; System.out.printf("%d%n", x); System.out.printf("%d%n", y); System.out.printf("%08X%n", ~x); System.out.printf("%08X%n". X & y); System.out.printf("%08X%n". X | y); System.out.printf("%08X%n". X ^ y); } }

Compound operator &=, |= and ^= are also available, e.g., x &= y is the same as x = x & y.

Take note that:

  1. '&', '|' and '^' are applicable when both operands are integers (int, byte, short, long and char) or booleans. When both operands are integers. They perform bitwise operations. When both operands are booleans, they perform logical AND, OR, XOR operations (i.e., same as logical &&, || and ^). They are not applicable to float and double. On the other hand. Logical AND (&&) and OR (||) are applicable to booleans only.

    System.out.println(true & true); System.out.println(0x1 & 0xffff); System.out.println(true && true); 
  2. The bitwise NOT (or bit inversion) operator is represented as ‘~’. Which is different from logical NOT (!).
  3. The bitwise XOR is represented as '^', which is the same as logical XOR (^).
  4. The operators’ precedence is in this order: '~', '&', '^', '|', '&&', '||'. For example,
    System.out.println(true | true & false); System.out.println(true ^ true & false); 

Bitwise operations are powerful and yet extremely efficient. [Example on advanced usage.]

13.2  Bit-Shift Operations

Bit-shift operators perform left or right shift on an operand by a specified number of bits. Right-shift can be either signed-extended (>>) (padded with signed bit) or unsigned-extended (>>>) (padded with zeros). Left-shift is always padded with zeros (for both signed and unsigned).

Operator Mode Usage Description Example
Binary x Left-shift and padded with zeros  
>> Binary x >> count Right-shift and padded with sign bit (signed-extended right-shift)  
>>> Binary x >>> count Right-shift and padded with zeros (unsigned-extended right-shift)  

Since all the Java’s integers (byte. Short. Int and long) are signed integers. Left-shift > operators perform signed-extended bit shift. Signed-extended right shift >> pads the most significant bits with the sign bit to maintain its sign (i.e.. Padded with zeros for positive numbers and ones for negative numbers). Operator >>> (introduced in Java. Not in C/C++) is needed to perform unsigned-extended right shift. Which always pads the most significant bits with zeros. There is no difference between the signed-extended and unsigned-extended left shift. As both operations pad the least significant bits with zeros.

Example
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
public class BitShiftTest { public static void main(String[] args) { int x = 0xAAAA5555; int y = 0x55551111; System.out.printf("%d%n", x); System.out.printf("%d%n", y); System.out.printf("%08X%n". X>1); System.out.printf("%d%n", x>>1); System.out.printf("%08X%n", y>>1); System.out.printf("%08d%n", y>>1); System.out.printf("%08X%n". X>>>1); System.out.printf("%d%n", x>>>1); System.out.printf("%08X%n", y>>>1); System.out.printf("%d%n". Y>>>1); int i1 = 12345; System.out.println("i1 divides by 2 is " + (i1 >> 1)); System.out.println("i1 divides by 4 is " + (i1 >> 2)); System.out.println("i1 divides by 8 is " + (i1 >> 3)); int i2 = -12345; System.out.println("i2 divides by 2 is " + (i2 >> 1)); System.out.println("i2 divides by 4 is " + (i2 >> 2)); System.out.println("i2 divides by 8 is " + (i2 >> 3)); } }

As seen from the example, it is more efficient to use sign-right-shift to perform division by 2, 4, 8… (power of 2). As integers are stored in binary.

[More example on advanced usage.]

13.3  Types and Bitwise Operations

The bitwise operators are applicable to integral primitive types: byte, short, int, long and char. char is treated as unsigned 16-bit integer. There are not applicable to float and double. The '&', '|', '^', when apply to two booleans, perform logical operations. Bit-shift operators are not applicable to booleans.

Like binary arithmetic operations:

  • byte, short and char operands are first promoted to int.
  • If both the operands are of the same type (int or long), they are evaluated in that type and returns a result of that type.
  • If the operands are of different types. The smaller operand (int) is promoted to the larger one (long). It then operates on the larger type (long) and returns a result in the larger type (long).

14.  Algorithms

Before writing a program to solve a problem. You have to first develop the steps involved. Called algorithm, and then translate the algorithm into programming statements. This is the hardest part in programming. Which is also hard to teach because the it involves intuition. Knowledge and experience.

An algorithm is a step-by-step instruction to accomplice a task. Which may involve decision and iteration. It is often expressed in English-like pseudocode, before translating into programming statement of a particular programming language. There is no standard on how to write pseudocode — simply write something that you. As well as other people. Can understand the steps involved. And able to translate into a working program.

14.1  Algorithm for Prime Testing

Ancient Greek mathematicians like Euclid and Eratosthenes (around 300-200 BC) had developed many algorithms (or step-by-step instructions) to work on prime numbers. By definition, a prime is a positive integer that is divisible by one and itself only.

To test whether a number x is a prime number, we could apply the definition by dividing x by 2, 3, 4, …, up to x-1. If no divisor is found. Then x is a prime number. Since divisors come in pair, there is no need to try all the factors until x-1, but up to x.

 int maxFactor = (int)Math.sqrt(x); assume x is a prime; for (int factor = 2; factor 

TRY: translate the above pseudocode into a Java program called PrimeTest.

14.2  Algorithm for Perfect Numbers

A positive integer is called a perfect number if the sum of all its proper divisor is equal to its value. For example. The number 6 is perfect because its proper divisors are 1, 2, and 3, and 6=1+2+3; but the number 10 is not perfect because its proper divisors are 1, 2, and 5, and 10≠1+2+5. Other perfect numbers are 28, 496, ...

The following algorithm can be used to test for perfect number:

 int sum = 0; for (int i = 1; i 

TRY: translate the above pseudocode into a Java program called PerfectNumberTest.

14.3  Algorithm on Computing Greatest Common Divisor (GCD)

Another early algorithm developed by ancient Greek mathematician Euclid (300 BC) is to find the Greatest Common Divisor (GCD) (or Highest Common Factor (HCF)) of two integers. By definition, GCD(a,b) is the largest factor that divides both a and b.

Assume that a and b are positive integers and a >= b, the Euclidean algorithm is based on these two properties:

1. GCD(a, 0) = a 2. GCD(a. B) = GCD(b, a mod b). Where "a mod b" denotes the remainder of a divides by b. 

For example,

GCD(15, 5) = GCD(5, 0) = 5 GCD(99,88) = GCD(88,11) = GCD(11,0) = 11 GCD(3456,1233) = GCD(1233,990) = GCD(990,243) = GCD(243,18) = GCD(18,9) = GCD(9,0) = 9

The Euclidean algorithm is as follows:

GCD(a, b) while (b != 0) { temp ← b b ← a mod b a ← temp } GCD is a

Before explaining the algorithm. Suppose we want to exchange (or swap) the values of two variables x and y. Explain why the following code does not work.

int x = 55, y=66; x = y; y = x;

To swap the values of two variables. We need to define a temporary variable as follows:

int x = 55, y=66; int temp; temp = y; y = x; x = temp;

Let us look into the Euclidean algorithm, GCD(a. B) = a, if b is 0. Otherwise. We replace a by b; b by (a mod b), and compute GCD(b, a mod b). Repeat the process until the second term is 0. Try this out on pencil-and-paper to convince yourself that it works.

TRY: Write a program called GCD, based on the above algorithm.

14.4  Exercises on Algorithm

LINK

15.  Summary

This chapter covers the Java programming basics:

  • Comments, Statements and Blocks.
  • Variables, Literals. Expressions.
  • The concept of type and Java’s eight primitive types: byte, short, int, long, float, double, char, and boolean; and String.
  • Implicit and explicit type-casting.
  • Operators: assignment (=), arithmetic operators (+, -, *, /, %), increment/decrement (++, --) relational operators (==, !=, >, >=, , ), logical operators (&&, ||, !, ^) and conditional (? :).
  • Three flow control constructs: sequential. Condition (if, if-else, switch-case and nested-if) and loops (while, do-while, for and nested loops).
  • Input (via Scanner) & Output (print(), println() and printf()) operations.
  • Arrays and the enhanced for-loop.
  • Methods and passing parameters into methods.
  • The advanced bitwise logical operators (&, |, ~, ^) and bit-shift operators (, >>, >>>).
  • Developing algorithm for solving problems.

Ссылка на Ссылки и ресурсы Java

More References and Resources

  1. (MUST READ) «Code Conventions for the Java Programming Language» @ https://www.oracle.com/technetwork/java/codeconvtoc-136057.html, or google the title. Sun Microsystems (now Oracle), 1999.