Основные типы величин в программировании сообщение

Эта HTML-версия Think Java предоставляется для удобства, но это не лучший формат книги. В частности, некоторые символы отображаются неправильно. Возможно , вы предпочтете прочитать PDF-версиюили купить печатную копию на Amazon. В этой главе описывается, как писать операторы с использованием переменных, которые хранят значения. Такие как числа и слова. И операторов. Которые являются символами. Выполняющими вычисления. Мы также объясняем три вида ошибок программирования и предлагаем дополнительные советы по отладке.

2.1 Объявление переменных

Одной из самых мощных функций языка программирования является возможность определять

переменные и манипулироватьими . Переменная — это именованное местоположение, в котором хранится значение. Значения могут быть числами, текстом, изображениями, звуками и другими типами данных. Чтобы сохранить значение, сначала нужно объявить переменную.

Строковое сообщение;

Этот оператор является объявлением, поскольку он объявляет, что переменная с именем messageимеет тип String. Каждая переменная имеет тип, который определяет, какие значения она может хранить. Например, intтип может хранить целые числа, а charтип-символы.

Некоторые типы начинаются с заглавной буквы, а некоторые-со строчной.

Мы узнаем значение этого различия позже, но сейчас вы должны позаботиться о том. Чтобы сделать это правильно. Нет такого типа, как Intили string.

Чтобы объявить целочисленную переменную с именем x, просто введите:

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

Строка FirstName; Строка LastName; int hour, minute;

В этом примере объявляются две переменные с типом

Stringи две с типом int. Когда имя переменной содержит более одного слова, например firstName, принято писать первую букву каждого слова. Кроме первой. Имена переменных чувствительны к регистру, поэтому firstNameне то же самое, что firstnameили FirstName.

Этот пример также демонстрирует синтаксис для объявления нескольких переменных с одним и тем же типом в одной строке: hourи minuteявляются целыми числами. Обратите внимание, что каждый оператор объявления заканчивается точкой с запятой.

Для переменной можно использовать любое имя. Но есть около 50 зарезервированных слов, называемых ключевымисловами . Которые вы не можете использовать в качестве имен переменных. Эти слова включают public, class, static, void, и int, которые используются компилятором для анализа структуры программы.

Полный список ключевых слов вы можете найти по адресу http://docs.oracle.com/javase/tutorial/java/nutsandbolts/_keywords.html-но вам не нужно их запоминать. Большинство программных редакторов обеспечивают “подсветку синтаксиса”. Которая заставляет различные части программы отображаться в разных цветах.

2.2 Назначение

Теперь, когда мы объявили переменные, мы хотим использовать их для хранения значений. Мы делаем это с помощью оператора присваивания.

message = ; // дать сообщению значение hour = 11; // присвоить значение 11 hour minute = 59; // установить minute to 59

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

  • При объявлении переменной создается именованное хранилище.
  • Когда вы делаете присвоение переменной, вы обновляете ее значение.

Как правило, переменная должна иметь тот же тип, что и присвоенное ей значение. Например, вы не можете хранить строку minuteили целое число message. Мы увидим некоторые примеры, которые, кажется, нарушают это правило, но мы вернемся к этому позже.

Общим источником путаницы является то, что некоторые строки выглядят как целые числа, но это не так. Например, messageможет содержать строку "123", которая состоит из символов '1', '2', и '3'. Но это не то же самое, что целое 123число .

message = ; // legal message = 123; // not legal

Переменные должны быть инициализированы (назначены в первый раз), прежде чем их можно будет использовать. Можно объявить переменную, а затем назначить значение позже, как в предыдущем примере. Вы также можете объявлять и инициализировать в одной строке:

Строковое сообщение = ; int hour = 11; int minute = 59;

2.3 Диаграммы состояний

Поскольку Java использует =символ для присваивания. Возникает соблазн интерпретировать оператор a = bкак утверждение равенства. Это не так!

Равенство коммутативно, а присвоение-нет. Например, в математике если а = 7, то 7 = а. В Java a = 7;есть юридический оператор присваивания, но 7 = a;это не так. Левая часть инструкции присваивания должна быть именем переменной (местом хранения).

Кроме того, в математике утверждение равенства верно для всех времен. Если a = b сейчас, то a всегда равно b. В Java оператор присваивания может сделать две переменные равными, но они не должны оставаться такими.

int a = 5; int b = a; // a и b теперь равны a = 3; // a и b больше не равны

Третья строка изменяет значениеa, но не меняет значения b, поэтому они больше не равны.

Взятые вместе, переменные в программе и их текущие значения составляют состояние программы . На рис. 2.1 показано состояние программы после выполнения этих операторов присваивания.

Рис. 2.1: Диаграмма состояний переменных aи.b

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

2.4 Переменные печати

Вы можете отобразить значение переменной с помощью printили println. Следующие операторы объявляют переменную с именем firstLine, присваивают ей значение "Hello, again!"и отображают это значение.

String firstLine = ; System.out.println(firstLine);

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

System.out.print(); System.out.println(Первая строка);

Для этого примера вывод будет следующим:

Значение firstLine-это Hello, again!

Удобно, что синтаксис отображения переменной одинаков независимо от ее типа. Например:

int hour = 11; int minute = 59; System.out.print(«Текущее время»); System.out.print(час); System.out. print(«:»); System.out.print(минута); System.out.println(«.»);

Выход этой программы таков:

Текущее время-11:59.

Для вывода нескольких значений в одной строке обычно используется несколько printоператоров. За которыми следует printlnв конце. Но не забывайте об printlnэтом ! На многих компьютерах выходные данные printхранятся без отображения до printlnтех пор. Пока не будут запущены; затем вся строка отображается сразу. Если вы опустите этот printlnпараметр . Программа может отображать сохраненные выходные данные в неожиданное время или даже завершиться. Ничего не отображая.

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

Операторы-это символы, представляющие простые вычисления. Например, оператор сложения +, вычитания -, умножения *и деления /.

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

int hour = 11; int minute = 59; System.out.print(); System.out.println(час * 60 + минута);

В этой программе hour * 60 + minuteесть выражение, которое представляет собой одно вычисляемое значение. При запуске программы каждая переменная заменяется ее текущим значением, а затем применяются операторы. Значения, с которыми работают операторы, называются операндами.

Результатом предыдущего примера является:

Количество минут с полуночи: 719

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

Например, выражение 1 + 1имеет значение 2. В выражении hour - 1Java заменяет переменную ее значением, yielding 11 - 1, которое имеет значение 10. В выражении hour * 60 + minuteобе переменные заменяются , давая 11 * 60 + 59результат . Умножение происходит первым, уступая 660 + 59. Тогда сложение дает 719результат .

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

System.out.print(); System.out.println(минута / 60);

Выход таков:

Доля прошедшего часа: 0

Этот результат часто сбивает людей с толку. Значение minuteравно 59, а 59, деленное на 60, должно быть 0,98333, а не 0. Проблема в том. Что Java выполняет “целочисленное деление”. Когда операнды являются целыми числами. По замыслу, целочисленное деление всегда округляется до нуля, даже в таких случаях, как этот. Когда следующее целое число близко.

В качестве альтернативы мы можем вычислить процент, а не долю:

System.out.print(); System.out.println(минута * 100/60);

Новый выход-это:

Процент от прошедшего часа: 98

Снова результат округляется вниз, но, по крайней мере, теперь он примерно правильный.

2.6 Числа с плавающей запятой

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

двойной пи; пи = 3,14159;

Java выполняет “деление с плавающей запятой”, когда один или несколько операндов являются doubleзначениями. Таким образом, мы можем решить проблему, которую видели в предыдущем разделе:

двойная минута = 59,0; System.out.print(); System.out.println(минута / 60,0);

Выход таков:

Доля прошедшего часа: 0.9833333333333333

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

Следующее является незаконным, поскольку переменная слева-это anint, а значение справа-adouble:

int x = 1.1; // ошибка компилятора

Это правило легко забыть потому что во многих случаях Java автоматически преобразует один тип в другой:

double y = 1; // легальный, но плохой стиль

Предыдущий пример должен быть незаконным, но Java позволяет это intсделать. Автоматически преобразуя значение 1в doubleзначение1.0. Такая снисходительность удобна, но она часто вызывает проблемы у новичков. Например:

double y = 1/3; // распространенная ошибка

Вы можете ожидать , что переменная yполучит значение0.333333, которое является законным значением с плавающей запятой. Но вместо этого он получает ценность 0.0. Выражение справа делит два целых числа, поэтому Java делает целочисленное деление. Которое дает intзначение 0. Преобразовано в double, значение. Присвоенное yis 0.0.

Один из способов решить эту проблему (как только вы поймете ошибку)-сделать правую часть выражением с плавающей запятой. Следующие наборы y0.333333, как и ожидалось:

double y = 1.0 / 3.0; // правильно

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

2.7 Ошибки округления

Большинство чисел с плавающей запятой верны лишь приблизительно. Некоторые числа, например целые числа разумного размера, могут быть точно представлены. Но повторяющиеся дроби, такие как 1/3, и иррациональные числа, такие как π, не могут. Чтобы представить эти числа, компьютеры должны округлить их до ближайшего числа с плавающей запятой.

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

System.out.println(0.1 * 10); System.out.println(0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1);

Но на многих машинах выход таков:

1.0 0.9999999999999999

Проблема в том , что 0.1то, что является завершающей дробью в десятичной системе счисления. Является повторяющейся дробью в двоичной. Таким образом, его представление с плавающей точкой является только приблизительным. Когда мы складываем аппроксимации, ошибки округления накапливаются.

Для многих приложений, таких как компьютерная графика, шифрование. Статистический анализ и мультимедийный рендеринг. Арифметика с плавающей запятой имеет преимущества. Которые перевешивают затраты. Но если вам нужна абсолютная точность, используйте вместо этого целые числа. Например, рассмотрим банковский счет с балансом $ 123,45:

двойной баланс = 123,45; // потенциальная ошибка округления

В этом примере балансы со временем станут неточными. Поскольку переменная используется в арифметических операциях. Таких как депозиты и снятие средств. В результате будут недовольные клиенты и потенциальные судебные иски. Вы можете избежать этой проблемы, представив баланс в виде целого числа:

int balance = 12345; // общее количество центов

Это решение работает до тех пор. Пока количество центов не превышает самое большое целое число. Которое составляет около 2 миллиардов.

2.8 Операторы для строк

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

— 1 / 123 *

+Оператор работает со строками, но он может делать не то, что вы ожидаете. Для строк +оператор выполняет конкатенацию, что означает соединение из конца в конец. Так "Hello, " + "World!"получается строка "Hello, World!".

Или если у вас есть переменная , nameкоторая имеет типString, выражение "Hello, " + nameдобавляет значение nameв строку приветствия. Которая создает персонализированное приветствие.

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

System.out.println(1 + 2 + «Hello»); // вывод-3Hello System.out.println(«Hello» + 1 + 2); // вывод-Hello12

Java выполняет эти операции слева направо. В первой строке 1 + 2есть 3и 3 + "Hello"есть "3Hello". Но во второй строке "Hello" + 1есть "Hello1"и "Hello1" + 2есть "Hello12".

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

  • Умножение и деление имеют “приоритет” над сложением и вычитанием, что означает. Что они происходят первыми. Таким 1 + 2 * 3образом, получается 7, а не 9, и 2 + 4 / 2получается 4, а не 3.
  • Если операторы имеют одинаковый приоритет, то они вычисляются слева направо. Таким образом , в выражении minute * 100 / 60сначала происходит умножение; если значение minuteравно 59, то мы получаем 5900 / 60, что дает 98. Если бы те же самые операции выполнялись справа налево, то результат был бы 59 * 1неправильным.
  • Каждый раз, когда вы хотите переопределить порядок операций (или вы не уверены, что это такое) . Вы можете использовать круглые скобки. Выражения в скобках вычисляются первыми, так (1 + 2) * 3же как и 9. Вы также можете использовать круглые скобки, чтобы сделать выражение более легким для чтения (minute * 100) / 60, даже если это не изменит результат.

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

2.9 Состав

До сих пор мы рассматривали элементы языка программирования – переменные, выражения и операторы – изолированно. Не говоря о том. Как их соединить.

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

System.out.println(17 * 3);

Внутри оператора print можно использовать любое арифметическое выражение. Мы уже видели один пример:

System.out.println(час * 60 + минута);

Вы также можете поместить произвольные выражения в правой части назначения:

int percentage; percentage = (минута * 100) / 60;

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

час = минута + 1; // правильная минута + 1 = час; // ошибка компилятора

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

2.10 Типы ошибок

В программе могут возникать три вида ошибок: ошибки во время компиляции. Ошибки во время выполнения и логические ошибки. Полезно различать их, чтобы быстрее отследить.

Ошибки времени компиляции возникают при нарушении правил синтаксиса языка Java. Например, скобки и фигурные скобки должны входить в соответствующие пары. Так (1 + 2)законно, но 8)это не так. В последнем случае программа не может быть скомпилирована, и компилятор выдает ошибку.

Сообщения об ошибках от компилятора обычно указывают, где в программе произошла ошибка. И иногда они могут точно сказать вам. Что это за ошибка. В качестве примера вернемся к программе hello world из раздела 1.4.

public class Hello { public static void main(String[] args) { // generate some simple output System.out.println(

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

Файл: Hello.java [строка: 5] Ошибка: ‘;’ ожидаемая

Это довольно хорошо: расположение ошибки правильно, и сообщение об ошибке говорит вам. Что не так.

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

Например, если вы оставите закрывающую скобку в конце main(строка 6). Вы можете получить сообщение следующего вида:

Файл: Hello.java [строка: 7] Ошибка: достигнут конец файла при разборе

Здесь есть две проблемы. Во-первых, сообщение об ошибке записывается с точки зрения компилятора, а не с вашей. Синтаксический анализ-это процесс чтения программы перед переводом; если компилятор добирается до конца файла во время анализа. Это означает. Что что-то было опущено. Но компилятор не знает, что именно. Он также не знает, где. Компилятор обнаруживает ошибку в конце программы (строка 7). Но отсутствующая скобка должна быть в предыдущей строке.

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

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

Второй тип ошибок-это ошибки временивыполнения , называемые так потому. Что они появляются только после запуска программы. В Java эти ошибки возникают, когда интерпретатор выполняет байт-код и что-то идет не так. Эти ошибки также называются “исключениями”, потому что они обычно указывают на то. Что произошло что-то исключительное (и плохое).

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

Например, если вы случайно делите на ноль, вы получите такое сообщение:

Исключение в потоке ArithmeticException: / by zero at Hello.main(Hello.java:5)

Некоторые части этого вывода полезны для отладки. Первая строка содержит имя исключения java.lang.ArithmeticExceptionи сообщение. Которое более конкретно указывает на то , что произошло / by zero. Следующая строка показывает метод, в котором произошла ошибка; Hello.mainуказывает метод mainв классе Hello. Он также сообщает файл, в котором определен метод, Hello.java, и номер строки, где произошла ошибка,5.

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

Третий тип ошибок-это логические ошибки. Если ваша программа имеет логическую ошибку. Она будет компилироваться и запускаться без генерации сообщений об ошибках. Но это будет неправильно. Вместо этого он будет делать именно то, что вы ему сказали. Например, вот версия программы hello world с логической ошибкой:

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

Эта программа компилируется и работает просто отлично, но на выходе получается:

Здравствуй, Мир!

Предполагая, что мы хотели получить вывод на одной строке, это неверно. Проблема в том , что первая строка использует printlnто, что мы, вероятно, хотели использовать print(см. Пример “прощай, мир” в разделе 1.5).

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

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

2.11 Словарный запас

переменная:
Именованное место хранения значений. Все переменные имеют тип, который объявляется при создании переменной.
ценность:
Число, строка или другие данные, которые могут быть сохранены в переменной. Каждое значение принадлежит типу (например, intor String).
декларация:
Оператор, который создает новую переменную и задает ее тип.
Тип:
Математически говоря, набор значений. Тип переменной определяет, какие значения она может иметь.
синтаксис:
Структура программы; расположение слов и символов, которые она содержит.
ключевое слово:
Зарезервированное слово, используемое компилятором для анализа программ. Вы не можете использовать ключевые слова (например public, class, и void) в качестве имен переменных.
назначение:
Оператор, который дает значение переменной.
инициализировать:
Чтобы назначить переменную в первый раз.
государство:
Переменные в программе и их текущие значения.
диаграмма состояния:
Графическое представление состояния программы в определенный момент времени.
оператор:
Символ, представляющий собой вычисление, такое как сложение, умножение или конкатенация строк.
операнд:
Одно из значений, на котором работает оператор. Большинство операторов в Java требуют двух операндов.
выражение:
Комбинация переменных, операторов и значений, представляющая одно значение. Выражения также имеют типы, определяемые их операторами и операндами.
плавающая точка:
Тип данных, представляющий числа с целой и дробной частью. В Java тип с плавающей запятой по умолчанию double.
ошибка округления:
Разница между числом, которое мы хотим представить, и ближайшим числом с плавающей запятой.
соединять:
Чтобы соединить два значения, часто строки, конец в конец.
порядок операций:
Правила, определяющие, в каком порядке оцениваются операции.
композиция:
Возможность объединения простых выражений и операторов в составные выражения и операторы.
ошибка времени компиляции:
Ошибка в исходном коде, которая делает невозможной компиляцию. Также называется “синтаксическая ошибка”.
разбор:
Проанализировать структуру программы; то, что компилятор делает в первую очередь.
ошибка во время выполнения:
Ошибка в программе, которая делает невозможным выполнение до завершения. Также называется “исключением”.
логическая ошибка:
Ошибка в программе, которая заставляет ее делать что-то не то, что задумал программист.

2.12 Упражнения

Код для этой главы находится в каталоге ch02 ThinkJavaCode. Видишь страницу ?? для получения инструкций о том. Как загрузить репозиторий. Прежде чем приступить к упражнениям, мы рекомендуем вам скомпилировать и запустить примеры.

Если вы еще не читали Приложение А. 2, сейчас самое время. Он описывает панель Взаимодействия DrJava. Которая является полезным способом разработки и тестирования коротких фрагментов кода без написания полного определения класса.

Упражнение 1  

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

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

Упражнение 2  

Смысл этого упражнения состоит в том. Чтобы (1) использовать конкатенацию строк для отображения значений с различными типами (int иString) и (2) практиковать постепенную разработку программ путем добавления нескольких операторов за раз.

  1. Создание новой программы с именем Date.java… Скопируйте или введите что-то вроде программы hello world и убедитесь. Что вы можете скомпилировать и запустить ее.
  2. Следуя примеру, приведенному в разделе 2.4, напишите программу, которая создает переменные с именамиday, date,month, и year. Переменная dayбудет содержать день недели (например. Пятница) и dateбудет содержать день месяца (например, 13-е). Какой тип имеет каждая переменная? Назначьте значения тем переменным, которые представляют сегодняшнюю дату.
  3. Отображение (распечатка) значения каждой переменной в отдельной строке. Это промежуточный шаг, который полезен для проверки того, что все работает до сих пор. Скомпилируйте и запустите свою программу, прежде чем двигаться дальше.
  4. Измените программу так, чтобы она отображала дату в стандартном американском формате, например: Четверг, 16 июля 2015года .
  5. Измените программу так, чтобы она также отображала дату в европейском формате. Конечный результат должен быть:

    Американский формат: Четверг, 16 июля 2015 г. Европейский формат: Четверг, 16 июля 2015 г.
Упражнение 3  

Смысл этого упражнения состоит в том. Чтобы (1) использовать некоторые арифметические операторы и (2) начать думать о составных сущностях (таких как время суток). Которые представлены несколькими значениями.

  1. Создайте новую программу под названием Time.java. Отныне мы не будем напоминать вам начинать с небольшой рабочей программы, но вы должны.
  2. Следуя примеру программы , приведенному в разделе 2.4, создайте переменные с именами hour, minute, и second. Назначьте значения, которые примерно соответствуют текущему времени. Используйте 24-часовые часы так, чтобы в 2 часа дня их значение hourбыло равно 14.
  3. Сделайте так, чтобы программа вычисляла и отображала количество секунд с полуночи.
  4. Рассчитать и отобразить количество секунд, оставшихся в день.
  5. Рассчитайте и отобразите процент прошедшего дня. Вы можете столкнуться с проблемами при вычислении процентов с целыми числами. Поэтому подумайте об использовании чисел с плавающей запятой.
  6. Измените значения hour, minute, иsecond, чтобы отразить текущее время. Затем напишите код для вычисления времени, прошедшего с момента начала работы над этим упражнением.

Подсказка: Возможно, вам захочется использовать дополнительные переменные для хранения значений во время вычислений. Переменные, которые используются в вычислениях, но никогда не отображаются. Иногда называются “промежуточными” или “временными” переменными.

Вы используете одну из наших книг в классе?

Мы хотели бы знать об этом. Пожалуйста, подумайте о том. Чтобы заполнить этот краткий опрос.

Подумайте о DSP

Думаю Java

Подумай Байес

Подумайте о Python 2e

Подумайте о статистике 2e

Подумайте о сложности