Переменные и типы данных в Java
Синтаксис является основой любого языка программирования. Java не является исключением. Поэтому если ты собираешься в будущем стать разработчиком, необходимо начать с азов. В этой статье мы рассмотрим, какие переменные бывают в языке Java и каковы основные типы данных.
Для того, чтобы тебе было проще понять, что такое переменная, вернемся к школьному курсу и вспомним простую формулу:
Если мы подставим значение к «х», например, х = 1, то значение выражения будет равно «2». Соответственно, если х = 2, значение выражения будет «3» и так далее. Как видишь, все достаточно просто. «Х» в нашем случае переменная, куда мы помещаем любое значение. Подставляя его в формулу, мы получаем определенный результат.
В языке программирования переменная – это своего рода контейнер или ящичек, куда можно положить любое значение, чтобы оно там хранилось до определенного момента, пока это значение нам не потребуется для каких-то вычислений.
В этом языке программирования выделяют четыре типа переменных:
Как видно, всего переменных 8, однако есть еще и девятый тип переменных – void. Но этот тип мы не будем рассматривать в данной статье. Познакомимся поближе с каждым из типов переменных.
Уже из названия понятно, что в качестве значения таким переменным присваиваются целые числа. Например, это может быть 5, 10, 25, 100 и так далее. Причем они могут быть как положительными, так и отрицательными, в зависимости от потребности разработчика. А теперь рассмотрим подробнее каждый из видов переменных:
В принципе, несложно понять, когда и в какой ситуации использовать каждую из этих переменных. Но для закрепления приведем маленький пример. Предположим, у Васи 5 апельсинов, а у Кати и Ани по 3. Нужно определить сколько всего апельсинов у ребят. Нетрудно догадаться, что здесь требуется использование целочисленных переменных, так как апельсины целые и не предполагается, что их будут делить на дольки.
Теперь нам нужно понять, какую именно переменную использовать. Здесь важно вспомнить, какое именно значение может принимать та или иная целочисленная переменная. Например, мы точно знаем, что количество апельсинов не будет выходить за пределы 127. В этом случае, можно смело объявлять byte.
Дальше, представим, что Вася, Катя и Аня выросли и стали заниматься поставками апельсинов. Теперь у каждого больше 1000 единиц этого вкусного фрукта. Объявлять byte мы больше не сможем. Если количество апельсинов не превышает 32767, мы можем работать с short, если больше с int и так далее.
Несмотря на то, что в Java представлено 4 целочисленных переменных, чаще всего будет использоваться только int. Более того этот тип в языке считается по умолчанию. А теперь посмотрим, как в Java объявляются переменные.
Как вы знаете тип переменной в java?
допустим, я объявляю переменную:
и я хочу знать, какой это тип, т. е. выход должен быть java.lang.String Как это сделать?
7 ответов
Если вам нужно имя, используйте метод Мартина. Если вы хотите знать, является ли это экземпляр определенного класса:
boolean b = a instanceof String
я узнал из поисковой системы(мой английский очень плохой, поэтому код. ) Как получить тип переменной? АП :
Я хотел бы расширить ответ Мартина есть.
его решение довольно приятно, но его можно настроить, чтобы любой «тип переменной» мог быть напечатан таким образом.(На самом деле это тип значения, еще по теме). Не так сильно изменено, как указывает на возможность.
если вы хотите, чтобы он работал с чем угодно, вы можете сделать это:
в этом случае примитив будет просто обернут в Обертка. В этом случае вы получите объект примитива.
Я сам использовал его так:
используйте функцию перегрузки оператора java
Я согласен с тем, что сказал Иоахим Зауэр, невозможно узнать (тип переменной! не тип значения!) если ваша переменная не является атрибутом класса (и вам нужно будет получить поля класса, получите правильное поле по имени. )
на самом деле для меня это совершенно невозможно что-либо a.xxx().yyy() метод даст вам правильный ответ, так как ответ будет отличаться на том же самом объекте в соответствии с контекстом, в котором вы вызываете этот метод.
как teehoo сказал, Если вы знаете при компиляции определенного списка типов для тестирования вы можете использовать instanceof, но вы также получите подклассы, возвращающие true.
одним из возможных решений также было бы вдохновить себя от реализации java.lang.reflect.Field и создайте свой собственный Field класс, а затем объявите все свои локальные переменные как этот пользовательский Field реализация. но вам лучше найти другое решение, мне действительно интересно, зачем нужен тип переменной, а не только тип значения?
Я думаю, что у нас есть здесь несколько решений:
почему? В Java все классы наследуются от класса Object. Поэтому, если у вас есть переменная, и вы хотели бы знать, какой тип это будет работать.
Как проверить тип переменной в Java?
Как я могу проверить, чтобы моя переменная была int, array, double и т.д.
Изменить: Например, как я могу проверить, что переменная является массивом? Есть ли какая-нибудь функция для этого?
Вы можете быть уверены, что он будет удерживать только int значения.
Однако, если вы считаете, что вам нужно это сделать, вы можете подумать о своем подходе. В большинстве случаев, если вы будете следовать объектно-ориентированным принципам, вам не нужно будет этого делать. Конечно, есть исключения для каждого правила.
На самом деле довольно легко свернуть собственный тестер, злоупотребляя способностью перегрузки Java. Хотя мне все еще интересно, есть ли в sdk официальный метод.
Это может случиться Я пытаюсь разобрать String в int, и я хотел бы знать, если мой Integer.parseInt(s.substring(a, b)) выбрасывает int или мусор, прежде чем я Integer.parseInt(s.substring(a, b)) итоги.
Кстати, это известно как отражение. Вот еще немного информации по этому вопросу: http://docs.oracle.com/javase/tutorial/reflect/
Вы можете работать с Integer вместо int, Double вместо double и т.д. (такие классы существуют для всех примитивных типов).
Затем вы можете использовать оператор instanceof, например if(var instanceof Integer)
Хорошо, я думаю, что проверка типа переменной может быть выполнена таким образом.
Таким образом, вам не нужно иметь несколько перегруженных методов. Я считаю хорошей практикой использовать коллекции по массивам из-за дополнительных преимуществ. Сказав это, я не знаю, как проверить тип массива. Может быть, кто-то может улучшить это решение. Надеюсь это поможет!
P.S Да, я знаю, что это также не проверяет примитивы.
Первая часть вашего вопроса бессмысленна. Нет никаких обстоятельств, при которых вы не знаете тип примитивной переменной во время компиляции.
Повторите вторую часть, единственное, что вы еще не знаете, является ли переменная массивом, является ли это объектом. В этом случае object.getClass().isArray() расскажет вам.
Я сделал это, используя: if(x.getClass() == MyClass.class)
Я не был доволен ни одним из этих ответов, и тот, у которого нет прав, не имеет объяснений и отрицательных голосов, поэтому я искал вокруг, нашел кое-что и отредактировал его, чтобы его было легко понять. Поиграйте с ним, не так прямо, как хотелось бы.
Ни один из этих ответов не работает, если переменная является неинициализированным универсальным типом
И из того, что я могу найти, это возможно только с помощью крайне уродливого обходного пути или путем передачи инициализированного параметра в вашу функцию, сделав его на месте, см. Здесь:
Это работает, потому что вызывающий абонент отвечает на инстанцировании переменную out перед вызовом. Это все равно будет выдавать исключение, если при вызове out is null, но по сравнению со связанным решением, это, безусловно, самый простой способ сделать это
Я знаю, что это своего рода конкретное приложение, но так как это первый результат в Google для поиска типа переменной с помощью Java (и учитывая, что T является разновидностью переменной), я чувствую, что это должно быть включено
Функция проверки вводимых значений на соответствие типу
В задаче необходимо сделать функцию проверки вводимых значений на соответствие тому или иному типу. Так вот вопрос какими средствами это можно реализовать в java? И приведите, пожалуйста, пример если не сложно.
8 ответов 8
Примерная канва решения:
P.S. Не компилировал и не проверял, я не компилятор 🙂
Я так понял Вам нужно определить тип переменной, я не большой специалист в Java но вижу два способа: 1. Java Строго типизированный язык, значит можно сохранить в массиве все типы и делать проверку типа объекта оператором instanceof:
Сделать свой тестер, что-то вроде
Потом создать объект и пошло-поехало.
Итак, у вас есть строковое значение, и вам необходимо проверить, является ли оно представлением заданного типа.
Для встроенных типов это не так сложно:
Кастомные типы должны уметь распознавать себя сами. Если они не умеют, «распознавалку» придётся писать вручную для каждого из типов.
Я бы сделал проверкой регулярным значением.
P.S. Загонять в Integer или Double и ждать Exception, не есть очень хорошо! Программе приходиться останавливаться и собирать стректрейс, а это операция не быстрая. Тем более это не исключительная ситуация для вашей программы. Не раз встречал парсинг строки в цифру с Exception у коллег, и приходилось им объяснять. Но судя по ответам это делают почти все, что очень грустно.
Решал подобную задачу на JavaRush, возможно, не самым элегантным, но работающим способом. По вводимому значению вызывается перегруженный под разные типы данных метод print. Ввод прекращается после ввода «exit»
Разбираемся в проверке JavaScript-типов с помощью typeof
Очень важный аспект любого языка программирования — это его система типов и типы данных в нем. Для строго типизированных языков программирования, например для таких как Java, переменные определяются конкретными типами, которые в свою очередь ограничивают значения переменных.
Несмотря на то, что JavaScript — это динамически типизированный язык программирования, существуют расширения над языком, которые поддерживают строгую типизацию, например TypeScript.
Для проверки типов в JavaScript присутствует довольно простой оператор typeof
Однако позже мы с вами увидим, что использование этого оператора может ввести в заблуждение, об этом мы поговорим ниже.
Типы данных в JavaScript
Перед тем как начать рассматривать проверку типов с помощью оператора typeof важно взглянуть на существующие типы данных в JavaScript. Хотя в этой статье не рассматриваются подробные сведения о типах данных JavaScript, вы все равно сможете что-то почерпнуть по мере чтения статьи.
Первые шесть типов данных относятся к примитивным типам. Все другие типы данных помимо вышеуказанных шести являются объектами и относятся к ссылочному типу. Объект — это не что иное, как коллекция свойств, представленная в виде пар ключ и значение.
Обратите внимание, что в указанном списке типов данных, null и undefined — это примитивные типы в JavaScript, которые содержат ровно одно значение.
Вы уже наверно начали задаваться вопросом, а как же массивы, функции, регулярные выражения и прочие вещи? Все это специальные виды объектов.
JavaScript содержит несколько конструкторов для создания и других различных объектов, например, таких как:
Проверка типов с использованием typeof
Синтаксис
Оператор typeof в JavaScript является унарным оператором (принимает только один операнд), который возвращает строковое значение типа операнда. Как и другие унарные операторы, он помещается перед его операндом, разделенный пробелом:
Однако существует альтернативный синтаксис, который позволяет использовать typeof похожим на вызов функции, через оборачивание операнда в круглые скобки. Это очень полезно при проверке типов возвращаемого значения из JavaScript-выражения:
Защита от ошибок
До спецификации ES6 оператор typeof всегда возвращал строку независимо от операнда, который использовал.
Для необъявленных идентификаторов функция typeof вернет “undefined” вместо того, чтобы выбросить исключение ReferenceError.
Переменные, имеющие блочную область видимости остаются во временной мертвой зоне до момента инициализации:
Проверка типов
Следующий фрагмент кода демонстрирует проверку типов c использованием оператора typeof :
Ниже представлена сводка результатов проверок типов:
Улучшенная проверка типов
Дополнительные проверки могут быть сделаны при использовании некоторых других характеристик, например:
Проверка на null
Очень важным здесь является использование оператора строгого сравнения. Следующий фрагмент кода иллюстрирует использования значения undefined :
Проверка на NaN
Любая арифметическая операция, включающая в выражение NaN, всегда определяется как NaN.
Если вы действительно хотите применить произвольное значения для любой арифметической операции, тогда убедитесь, что это значение не NaN.
Значение NaN в JavaScript имеет отличительную особенность. Это единственное значение в JavaScript, которое при сравнении с каким-либо другим значением, включая NaN, не будет ему эквивалентно
Вы можете проверить на значение NaN следующим образом
Проверка для массивов
Очень важным здесь является использование оператора строгого сравнения. Следующий фрагмент кода иллюстрирует использования значения undefined :
Общий подход к проверке типов
Как вы видели на примере массивов, метод Object.prototype.toString() может быть полезным при проверки типов объектов для любого значения в JavaScript.
Рассмотрим следующий фрагмент кода:
Фрагмент кода ниже демонстрирует результаты проверки типов с использованием созданной функции type() :
Бонус: не все является объектами
Очень вероятно, что в какой-то момент вы могли столкнуться с этим утверждением:
“Все сущности в JavaScript являются объектами.” — Неправда
Это ошибочное утверждение и на самом деле это неправда. Не все в JavaScript является объектами. Примитивы не являются объектами.
Вы можете начать задаваться вопросом — почему же мы можем делать следующие операции над примитивами, если они не являются объектами?
Причина, по которой мы можем достичь всего этого над примитивами, заключается в том, что JavaScript-движок неявно создает соответствующий объект-обертку для примитива и затем вызывает указанный метод или обращается к указанному свойству.
Когда значение было возвращено, объект-обертка отбрасывается и удаляется из памяти. Для операций, перечисленных ранее, JavaScript-движок неявно выполняет следующие действия:
Заключение
Также вы видели, как проверка типов с помощью оператора typeof может ввести в заблуждение. И, наконец, вы видели несколько способов реализации предсказуемой проверки типов для некоторых типов данных.
Если вы заинтересованы в получении дополнительной информации об операторе typeof в JavaScript, обратитесь к этой статье.
