В последнем «эпизоде» я смог настроить среду и начать новое приключение в изучении Java. Я почти ничего не сделал, кроме записи некоторых переменных и вывода на терминал. Важно то, что в части 1 я смог начать новый опыт обучения и доказать себе и работодателям, что продолжение обучения — это то, чего следует ожидать. Я планирую продолжить эту серию блогов, поскольку я продолжаю изучать Java, работать полный рабочий день, искать работу для своей первой работы в области технологий и вносить свой вклад в мой текущий проект, созданный на Ruby, Rails и React.
В этом блоге я продолжу изучать простые концепции и укреплять основы, которые могут отличаться от того, к чему я привык в других языках.
Выражения и работа с переменными
Мой класс Udemy дал мне небольшой вызов коду, который я ценю. Это будет хорошей практикой для синтаксиса, поможет мне критически мыслить и не потеряет внимание.
Задача:
Создайте пару переменных (myFirstNum, mySecondNum, total) и создайте с ними несколько выражений.
Создайте новую переменную с именем myLastNum, которая равна 1000, а общее количество удалено.
Распечатайте значение myLastNum.
Ключевым моментом здесь является понимание прочитанного, так как мне нужно выяснить, какой оператор для чего использовать. Задача состоит в том, чтобы найти, что равно 1000 минуснашасумма. Это довольно явный признак того, что нужно использовать оператор вычитания, вычесть итог из 1000 и сохранить это значение в нашей переменной myLastNum.
public class Practice { public static void main(String[] args) { int myFirstNum = 500; int mySecondNum = 200; int total = myFirstNum + mySecondNum; //700 int myLastNum = 1000 - total; System.out.println(myLastNum); //prints 300 } }
Примитивные типы
8 примитивных типов данных в Java:
- Логическое значение — Истина/Ложь.
- Байт — сохраняет целые числа от -128 до 127.
- Short — сохраняет целые числа от -32 768 до 32 767.
- Int — сохраняет целые числа от -2 147 483 648 до 2 147 483 647.
- Long — сохраняет целые числа от -9 223 372 036 854 775 808 до 9 223 372 036 854 775 807.
- Float — хранит дробные числа. Достаточно для хранения от 6 до 7 десятичных цифр.
- Double — сохраняет дробные числа. Достаточно для хранения 15 десятичных цифр.
- Char — сохраняет один символ/букву или значения ASCII.
Это довольно интересно, так как я знаком только с логическими значениями, int и float из Ruby и JavaScript. Использование соответствующих типов данных может сократить объем памяти, выделяемой вашим кодом.
Оболочка — Java использует концепцию оболочки для всех 8 примитивных типов. Классы-оболочки позволяют использовать примитивные типы данных в качестве объектов. Затем вы можете выполнить определенные методы для этих классов.
байт — Байт
короткий — короткий
интервал — целое число
долго долго
плавать — плавать
двойной — двойной
логический — логический
символ — Персонаж
public class Main {
public static void main(String[] args) {
Integer myInt = 5;
Double myDouble = 5.99;
Character myChar = 'A';
System.out.println(myInt);
System.out.println(myDouble);
System.out.println(myChar);
}
}
Приведение — обработка или преобразование типа в другой тип данных.
Если бы мы объявили новую переменную, содержащую байтовое значение, и использовали бы ее в таком выражении:
byte byteNum = 10; byte myNewByteNum = byteNum / 2;
На самом деле это приведет к ошибке, потому что внутри круглых скобок переменная обрабатывается как целое число, значение которого, как мы знаем, равно 10, и оно соответствует типу данных byte. Нам нужно использовать приведение, чтобы рассматривать byteNum как байт.
byte byteNum = 10; byte myNewByteNum = (byte)(byteNum / 2);
Была поставлена новая задача:
Создайте переменную byte и задайте для нее любое допустимое значение в байтах.
Создайте значение short и задайте для него любое допустимое короткое значение.
Создайте значение int и установите для него любое допустимое значение int.
Создайте переменную типа long и установите ее равной 50000 плюс 10-кратная сумма byte, short и значение int.
byte byteNum = 5; short shortNum = 10; int intNum = 20; long myLongNum = 50000L + 10 * (byteNum + shortNum + intNum); System.out.println(myLongNum);
Числа с плавающей запятой
Числа с плавающей запятой (также известные как действительные числа) — это числа с десятичными знаками для более точных вычислений.
Различают одинарную и двойную точность. Точность относится к формату и пространству, занимаемому шрифтом. Single занимает 32 бита или (4 байта), а double занимает 64 бита или 8 байтов. Было высказано предположение, что двойники являются лучшим типом данных для программирования, поскольку двойники более точны и быстрее вычисляются за счет того, что они занимают больше места. Предполагается, что числа с плавающей запятой удваиваются java, если они не помечены.
Синтаксис для объявления чисел с плавающей запятой и двойников как переменных:
//float float myFloat = 5.25f; //double double myDouble = 5.25d; //without using d or f after the declaration java will assume it is a double.
Символ и логическое значение
Символ
Символы отличаются от строк. Chars может хранить только 1 символ. Символ занимает 2 байта в памяти. Это потому, что char используется для хранения юникода. Вы можете просмотреть таблицу юникода и найти подходящее значение.
char myChar = '\u0040'; //myChar's value will be the letter 'D'
логическое значение
Правда или ложь
boolean myBoolean = true;
Струны
Строки не являются примитивным типом, но это класс. Он ведет себя как тип данных, поэтому его следует включить в этот блог.
Строки представляют собой последовательность символов. Максимальное значение строки в памяти составляет 2,14 миллиарда. Строки неизменяемы, то есть вы не можете изменить строку после ее создания. Когда вы «меняете» их, вы создаете новую строку и отбрасываете старую.
Вы также можете интерполировать строки, используя оператор сложения.
String myString = "Adam"; System.out.println("Hello, " + myString );
Выводы
Очень интересно изучать новый язык после того, как уже знаешь несколько. У меня сложилось впечатление, что все будет в основном одинаково с некоторыми небольшими отличиями в синтаксисе, но я ошибался. Есть типы данных, о которых я никогда не слышал, и большое внимание уделяется тому, сколько места они занимают в памяти. Я знаю, что это также будет присутствовать, когда я перейду к структурам данных и сосредоточусь на оперативной памяти. Исходя из других языков, я не видел такого пристального внимания к тому, что происходит под капотом. Мне интересно посмотреть, насколько больше изменится опыт обучения по мере того, как я продолжаю. Спасибо за чтение!