Как создать калькулятор на Java — полное руководство с кодом
В этом руководстве мы расскажем, как создать калькулятор на Java для Android. Если вы новичок в программировании и никогда раньше не создавали приложения, ознакомьтесь с нашим предыдущим руководством по написанию первого приложения для Android:
Предполагается, что у вас есть хотя бы минимальный базовый опыт создания Android – приложений .
Полный исходный код калькулятора, описанного ниже, доступен для использования и изменения на github.
Создание проекта
Первое, что нужно сделать — это создать в Android Studio новый проект: Start a new Android Studio project или File — New — New Project :
Для этого руководства мы выбрали в панели « Add an Activity to Mobile » опцию « EmptyActivity », для « MainActivity » мы оставили имя по умолчанию – « Activity ». На этом этапе структура должна выглядеть, как показано на рисунке ниже. У вас есть MainActivity внутри пакета проекта и файл activity_main.xml в папке layout :
Включение привязки данных в проекте
Перед тем, как создать приложение для Андроид с нуля, нужно уяснить, что использование привязки данных помогает напрямую обращаться к виджетам ( Buttons , EditText и TextView ), а не находить их с помощью методов findViewById() . Чтобы включить привязку данных, добавить следующую строку кода в файл build.gradle .
android < . dataBinding.enabled = true .
Разработка макета калькулятора
Для включения привязки данных в файле activity_main.xml требуется еще одно изменение. Оберните сгенерированный корневой тег ( RelativeLayout ) в layout , таким образом сделав его новым корневым тегом.
Как научиться создавать приложения для Андроид? Читайте наше руководство дальше.
Тег layout - это предупреждает систему построения приложения, что этот файл макета будет использовать привязку данных. Затем система генерирует для этого файла макета класс Binding . Поскольку целевой XML-файл называется activity_main.xml , система построения приложения создаст класс ActivityMainBinding , который можно использовать в приложении, как и любой другой класс Java . Имя класса составляется из имени файла макета, в котором каждое слово через подчеркивание будет начинаться с заглавной буквы, а сами подчеркивания убираются, и к имени добавляется слово « Binding ».
Теперь перейдите к файлу MainActivity.java . Создайте закрытый экземпляр ActivityMainBinding внутри вашего класса, а в методе onCreate() удалите строку setContentView () и вместо нее добавьте DataBindingUtil.setContentView() , как показано ниже.
public class MainActivity extends AppCompatActivity < private ActivityMainBinding binding; @Override protected void onCreate(Bundle savedInstanceState) < super.onCreate(savedInstanceState); binding = DataBindingUtil.setContentView(this, R.layout.activity_main); >>
Общие принципы создания виджетов макета
В приложении калькулятора есть четыре основных элемента:
RelativeLayout - определяет, как другие элементы будут укладываться или отображаться на экране. RelativeLayout используется для позиционирования дочерних элементов по отношению друг к другу или к самим себе.
TextView - элемент используется для отображения текста. Пользователи не должны взаимодействовать с этим элементом. С помощью TextView отображается результат вычислений.
EditText - похож на элемент TextView, с той лишь разницей, что пользователи могут взаимодействовать с ним и редактировать текст. Но поскольку калькулятор допускает только фиксированный набор вводимых данных, мы устанавливаем для него статус « не редактируемый ». Когда пользователь нажимает на цифры, мы выводим их в EditText .
Button - реагирует на клики пользователя. При создании простого приложения для Андроид мы используем кнопки для цифр и операторов действий в калькуляторе.
Создание макета калькулятора
Код макета калькулятора объемный. Это связано с тем, что мы должны явно определять и тщательно позиционировать каждую из кнопок интерфейса. Ниже представлен фрагмент сокращенной версии файла макета activity_main :
Внутренние компоненты калькулятора
Перед тем, как создать приложение на телефон Android , отметим, что valueOne и valueTwo содержат цифры, которые будут использоваться. Обе переменные имеют тип double , поэтому могут содержать числа с десятичными знаками и без них. Мы устанавливаем для valueOne специальное значение NaN ( не число ) - подробнее это будет пояснено ниже.
private double valueOne = Double.NaN; private double valueTwo;
Этот простой калькулятор сможет выполнять только операции сложения, вычитания, умножения и деления. Поэтому мы определяем четыре статических символа для представления этих операций и переменную CURRENT_ACTION , содержащую следующую операцию, которую мы намереваемся выполнить.
private static final char ADDITION = '+'; private static final char SUBTRACTION = '-'; private static final char MULTIPLICATION = '*'; private static final char DIVISION = '/'; private char CURRENT_ACTION;
Затем мы используем класс DecimalFormat для форматирования результата. Конструктор десятичного формата позволяет отображать до десяти знаков после запятой.
decimalFormat = new DecimalFormat("#.##########");
Обработка нажатий на цифры
В нашем создаваемом простом приложении для Андроид всякий раз, когда пользователь нажимает на цифру или точку, нам нужно добавить эту цифру в editText . Пример кода ниже иллюстрирует, как это делается для цифры ноль ( 0 ).
binding.buttonZero.setOnClickListener(new View.OnClickListener() < @Override public void onClick(View view) < binding.editText.setText(binding.editText.getText() + "0"); >>);
Обработка кликов по кнопкам операторов
Обработка нажатия кнопок операторов ( действий ) выполняется по-другому. Сначала нужно выполнить все ожидающие в очереди вычисления. Поэтому мы определяем метод computeCalculation . В computeCalculation , если valueOne является допустимым числом, мы считываем valueTwo из editText и выполняем текущие операции в очереди. Если же valueOne является NaN , для valueOne присваивается цифра в editText .
private void computeCalculation() < if(!Double.isNaN(valueOne)) < valueTwo = Double.parseDouble(binding.editText.getText().toString()); binding.editText.setText(null); if(CURRENT_ACTION == ADDITION) valueOne = this.valueOne + valueTwo; else if(CURRENT_ACTION == SUBTRACTION) valueOne = this.valueOne - valueTwo; else if(CURRENT_ACTION == MULTIPLICATION) valueOne = this.valueOne * valueTwo; else if(CURRENT_ACTION == DIVISION) valueOne = this.valueOne / valueTwo; >else < try < valueOne = Double.parseDouble(binding.editText.getText().toString()); >catch (Exception e)<> > >
Продолжаем создавать копию приложения на Андроид . Для каждого оператора мы сначала вызываем computeCalculation() , а затем устанавливаем для выбранного оператора CURRENT_ACTION . Для оператора равно (=) мы вызываем computeCalculation() , а затем очищаем содержимое valueOne и CURRENT_ACTION .
Заключение
Если вы запустите и протестируете данное приложение, то увидите некоторые моменты, которые можно улучшить: 1) возможность нажимать на кнопку оператора, когда editText очищен ( т. е. без необходимости ввода первой цифры ), 2) возможность продолжать вычисления после нажатия кнопки « Равно ».
Полный код примера доступен на github.
Базовая программа калькулятор с использованием Java
Два числа, а также оператор задаются от пользователя. Фрагмент кода, демонстрирующий это, приведен ниже:
double num1; double num2; double ans; char op; Scanner reader = new Scanner(System.in); System.out.print("Enter two numbers: "); num1 = reader.nextDouble(); num2 = reader.nextDouble(); System.out.print("\nEnter an operator (+, -, *, /): "); op = reader.next().charAt(0);
Переключатель используется для выполнения указанной операции над двумя числами. Если введенный оператор неверен, отображается сообщение об ошибке.
switch(op) < case '+': ans = num1 + num2; break; case '-': ans = num1 - num2; break; case '*': ans = num1 * num2; break; case '/': ans = num1 / num2; break; default: System.out.printf("Error! Enter correct operator"); return; >
Наконец, выводится результат.
System.out.print("\nThe result is given as follows:\n"); System.out.printf(num1 + " " + op + " " + num2 + " rmp-widgets-container rmp-wp-plugin rmp-main-container js-rmp-widgets-container js-rmp-widgets-container--3919 " data-post-id="3919">
Средняя оценка 4.4 / 5. Количество голосов: 74
Спасибо, помогите другим - напишите комментарий, добавьте информации к статье.
Или поделись статьей
Видим, что вы не нашли ответ на свой вопрос.
Помогите улучшить статью.
Напишите комментарий, что можно добавить к статье, какой информации не хватает.
-->Шенденков С.В.
(Zmey) -->
Так как мы уже разобрались из чего состоит класс и как писать консольные приложения, давайте напишем нашу первую полезную программу. Мы напишем простейший калькулятор.
Первое, что нам необходимо сделать, это создать новый проект консольного приложения и назвать его, например MyCalculator. После создания нового проекта мы конечно же увидим основной класс приложения, в котором можно описать всю логику калькулятора. Но чтобы научиться чему-то новому и чтобы просто было интересно давайте дополнительно в нашем проекте задействуем интерфейс Java. Интерфейс в Java - это специальная конструкция, которая описывает обязательную структуру использующего её класса. Более простым языком это означает, что если мы хотим создать объект, то для этого нам необходимо определить класс этого объекта. А если нам необходимо задать правила построения этого класса, то нам необходим интерфейс. Это очень важная вещь при наследовании классов. Про наследование классов мы поговорим попозже, а сейчас мы научимся работать с интерфейсом.
Если мы посмотрим в левой части NetBeans'a на структуру проекта, то увидим что наш основной класс лежит в определённо папке. Эта папка и является его пакетом. Теперь нажмём на этот пакет правой кнопкой мыши и выберем раздел Создать. Здесь мы увидим много различных элементов, которые мы может создать прямо сейчас. Давайте создадим новый Интерфейс Java и назовём его PrimitiveCalculator. Как мы видим внешне его структура абсолютно такая же как и у класса, но вместо ключевого слова class здесь имеется ключевое слово interface.
Главное отличие интерфейса от класса в том, что здесь не описывается объект, а только объявляется какими обязательными элементами он должен обладать объект, если его класс будет использовать данный интерфейс. Приведём наш интерфейс к такому виду:
package zmey_console_calculator_example;
* Интерфейс примитивного калькулятора
* @author Zmey
* @author http://shendenkov.at.ua
public interface PrimitiveCalculator <
public double add( double a, double b);
public double sub( double a, double b);
public double mul( double a, double b);
public double div( double a, double b);
Как видите интерфейс довольно простой и лаконичный. Здесь объявляются 4 метода, которые обязательно должны быть описаны в классе который будет использовать этот интерфейс.
Теперь давайте вернёмся к нашему основному классу и приведём его к следующему виду:
package zmey_console_calculator_example;
* Простой калькулятор
* @author Zmey
* @author http://shendenkov.at.ua
public class MyCalculator implements PrimitiveCalculator <
public MyCalculator( double a, String o, double b) <
if (o.equals( "+" )) <
System. out .println(a + " + " + b + " color: rgb(220, 220, 220);">+ add(a,b));
if (o.equals( "-" )) <
System. out .println(a + " + " + b + " color: rgb(220, 220, 220);">+ sub(a,b));
if (o.equals( "*" )) <
System. out .println(a + " + " + b + " color: rgb(220, 220, 220);">+ mul(a,b));
if (o.equals( "/" )) <
System. out .println(a + " + " + b + " color: rgb(220, 220, 220);">+ div(a,b));
System. out .println( "Unknown operation" );
public double add( double a, double b) <
return a + b;
public double sub( double a, double b) <
return a - b;
public double mul( double a, double b) <
return a * b;
public double div( double a, double b) <
return a / b;
* @param args the command line arguments
public static void main(String[] args) <
if (args. length >= 3) <
new MyCalculator(Double.valueOf(args[0]), args[1],
Double.valueOf(args[2]));
System. out .println( "Enter parameters like this: 1 + 1" );
Давайте разберёмся, что здесь описано. Добавилось ключевое слово implements, которое как бы подключает используемый интерфейс PrimitiveCalculator. В конструктор принимаются параметры типа double и String, описывается вся логика работы калькулятора с помощью методов add, sub, mul и div. Эти метода как раз и являются теми методами, которые обязательно должны присутствовать в нашем классе, потому что мы используем созданный ранее интерфейс. Также мы используем ключевое слово return, после которого идёт возвращаемое значение этого метода если он что-то возвращает. Это ключевое слово сразу же прекращает выполнение метода, в котором оно вызвано. Оно обязательно должно присутствовать в методе. Для методов, которые ничего не возвращают его можно не указывать - NetBeans автоматически его подставляет неявным образом.
Обратите внимание, что в методе main мы создаём новый объект типа MyCalculator, но не помещаем его ни в одну переменную и он сразу же исчезает. Что, естественно, не имеет никакого смысла, если бы нам необходимо было его использовать дальше и поэтому NetBeans пометит это как предупреждение. Но тем не менее объект на мгновение создаётся и в процессе создания выполняет все необходимые нам операции.
Для выполнения программы ей необходимы 3 параметра, а именно число, операция и число. Прямо как в математике. Чтобы их передать программе необходимо её запускать в командной строке и через пробел после названия программы писать параметры. Но эти параметры можно задать и в NetBeans для проверки работы программы. Для этого нажмём правой кнопкой мыши на текущий проект, выберем Свойства, перейдём в категорию Выполнить, в поле Аргументы укажем необходимые нам аргументы и нажмём OK. Теперь как только мы будем запускать этот проект в NetBeans, он автоматически будет подставлять эти параметры в метод main. Всё как пользователь будет делать вручную в командной строке.
popin
Необходимо написать простой консольный калькулятор на Java.
Для считывания ввода нужно использовать класс Scanner.
Scanner позволяет считывать строки и числа:
Scanner scanner = new Scanner(System.in);
int operand1 = scanner.nextInt(); //считывает число
/* Метод next() класса Scanner считывает строку,
а метод charAt(0) позволяет взять первый символ в этой строке.
так мы получаем операцию, которую нужно выполнить*/
char operation = scanner.next().charAt(0);
Теперь у нас есть первый операнд и операция, которую необходимо выполнить. Осталось считать второй операнд, и выполнить нужное действие в зависимости от того, какая операция была введена.
в конце напечатать результат.
Ответьте на следующие вопросы прежде чем приступить к написанию кода:
1. Какой оператор лучше использовать, чтобы проверить, какую операцию выполнять? (switch)
2. Если пользователь ввёл не поддерживаемую операцию стоит ли ему сообщить об этом? ( проверка ввода .. предупредить об ошибке)
3. Нужна ли дополнительная переменная для второго операнда? А для результата? (operand2 для второго и result для результата)
4. Можно ли написать весь код в одном методе? или вынести код для каждой операции отдельно? (лучше разнести получение одного, второго операнда и знака операции отдельно, и отдельный метод для расчета)
прежде чем решать данную задачу, необходимо разбить задачу на подзадачи. всего есть 3 основных шага:
Шаг №1 вводятся 2 числа ->> метод getInt()
Шаг №2 выбирается операция ->> метод char getOperation()
Шаг №3 Калькулятор считает ->> метод int calc(int operand1, int operand2, char operation)
поэтому в методе int nextInt() мы прописали механику считывания числа с консоли и проверки целочисленное число введено или нет.
public static int nextInt() System.out.println("Введите число:");
int operand;
if(scanner.hasNextInt()) operand = scanner.nextInt();
> else System.out.println("Вы допустили ошибку при вводе числа. Попробуйте еще раз.");
scanner.next();//рекурсия
operand = nextInt();
>
return operand;
>
и потом просто в методе main() вызовем 2 раза метод int nextInt(),
потому что пользователь будет вводить 2 числа.
Обратите внимание, что с помощью конструкции if-else мы прописали, что если число целочисленное, тогда присвоить введенное пользователем значение в переменную operand, если же не целочисленное, - вывести в консоль "Вы допустили ошибку при вводе числа. Попробуйте еще раз".
Также обратите внимание, что мы использовали рекурсию в else:
> else System.out.println("Вы допустили ошибку при вводе числа. Попробуйте еще раз.");
scanner.next();//рекурсия
operand = nextInt();
>
Выбо операции (+ - * /) мы осуществили с помощью метода char getOperation()
public static char getOperation() System.out.println("Введите операцию:");
char operation;
if(scanner.hasNext()) operation = scanner.next().charAt(0);
> else System.out.println("Вы допустили ошибку при вводе операции. Попробуйте еще раз.");
scanner.next();//рекурсия
operation = getOperation();
>
return operation;
>
Как видите, пользователю предлагается ввести операцию. А далее программа должна распознать было ли введеное пользователем значение типа char или нет. Причем нас устроит только, если пользователь введет: + - * или / . Например, если пользователь введет число, нас не устроит. Вероно? Поэтому мы применили небольшую хитрость вот в этих 2 строчках кода:
if(scanner.hasNext()) operation = scanner.next().charAt(0);
Мы с помощью метода сканера next() считали всю строчку. А далее, поскольку нам не нужна вся строка, а нужен только первый элемент строки, то есть нулевой элемент, поэтому мы вызвали еще и метод charAt(0). И таким образом мы получим только значение 0-го элемента, а не всей строки.
И далее мы прописали сам метод int calc(int operand1, int operand2, int operation):
public static int calc(int operand1, int operand2, char operation) int result;
switch (operation) case '+':
result = operand1+operand2;
break;
case '-':
result = operand1-operand2;
break;
case '*':
result = operand1*operand2;
break;
case '/':
result = operand1/operand2;
break;
default:
System.out.println("Операция не распознана. Повторите ввод.");
result = calc(operand1, operand2, getOperation());//рекурсия
>
return result;
>
Как видите, мы использовали конструкцию switch-case. И прописали, что:
если пользователь ввел +, тогда operand1+operand2, то есть суммируем 2 числа, введенных пользователем.
если пользовательввел -, тогда operand1-operand2, то есть из 1-го числа, введенного пользователем вычитаем 2-е число
также обратите внимание, что здесь мы тоже использовали рекурсию.
default:
System.out.println("Операция не распознана. Повторите ввод.");
result = calc(operand1, operand2, getOperation());//рекурсия
и после того как мы прописали все необходимые методы, мы в методе main() прописали следующее:
public static void main(String[] args) int operand1 = nextInt();
int operand2 = nextInt();
char operation = getOperation();
int result = calc(operand1,operand2,operation);
System.out.println("Результат операции: "+result);
>
то есть в переменные operand1 и operand2 будут присвоены,
соответственно, 1-е и 2-е число, введенное пользователем.
в переменнную operation будет присвоенна операция, которую ввел пользователь: + - * или /
далее в переменную result будет присвоен рузультат вычислений нашего калькулятора
и после этого результат будет выведен в консоль
ниже приведем весь код калькулятора
import java.util.Scanner;
public class Calculator static Scanner scanner = new Scanner(System.in);
public static void main(String[] args) int operand1 = nextInt();
int operand2 = nextInt();
char operation = getOperation();
int result = calc(operand1,operand2,operation);
System.out.println("Результат операции: "+result);
>
public static int nextInt() System.out.println("Введите число:");
int operand;
if(scanner.hasNextInt()) operand = scanner.nextInt();
> else System.out.println("Вы допустили ошибку при вводе числа. Попробуйте еще раз.");
scanner.next();//рекурсия
operand = nextInt();
>
return operand;
>
public static char getOperation() System.out.println("Введите операцию:");
char operation;
if(scanner.hasNext()) operation = scanner.next().charAt(0);
> else System.out.println("Вы допустили ошибку при вводе операции. Попробуйте еще раз.");
scanner.next();//рекурсия
operation = getOperation();
>
return operation;
>
public static int calc(int operand1, int operand2, char operation) int result;
switch (operation) case '+':
result = operand1+operand2;
break;
case '-':
result = operand1-operand2;
break;
case '*':
result = operand1*operand2;
break;
case '/':
result = operand1/operand2;
break;
default:
System.out.println("Операция не распознана. Повторите ввод.");
result = calc(operand1, operand2, getOperation());//рекурсия
>
return result;
>
>