Примитивные типы в java
Содержание:
- Типы данных примитивов
- Типы объектов
- Выделение памяти
- Ссылочные [ править ]
- Primitive Data Types
- Диапазоны значений и знак целочисленных типов данных
- Оператор instanceof
- Инициализация переменных
- ⇑
- 7. Пример описания и использования переменных с плавающей запятой.
- 8. Какие особенности применения символьного типа данных char?
- 9. Примеры описания и использования переменных типа char
- 10. Какое назначение в программах имеет тип boolean?
- 11. Какие отличия между примитивными типами и типами-ссылками?
- 12. Существуют ли беззнаковые примитивные типы?
- Иерархии параметризованных классов
- Используя Символы подчеркивания в Числовых Литералах
- Что такое Generics в Java?
- Обновлённый оператор switch в Java 14
- Методы класса
- Методы
- Класс Object и его методы
- Структуры данных
Типы данных примитивов
В Java всего восемь примитивных типов данных: байт, короткий, int, long, float, double, char и boolean. Программа Java не может определять какие-либо другие примитивные типы данных. Примитивы используются так часто, что делает их объекты значительно ухудшающими производительность. Примитивные типы данных следующие:
Python
boolean — Non-numeric value of true or false.
byte — An 8-bit (1-byte) integer value
char — A 16-bit character using the Unicode encoding scheme
short — A 16-bit (2-byte) integer value
int — A 32-bit (4-byte) integer value
long — A 64-bit (8-byte) integer value
float — A 32-bit (4-byte) floating-point value
double — A 64-bit (8-byte) floating-point value
|
1 |
boolean-Non-numeric value of trueorfalse. byte-An8-bit(1-byte)integer value char-A16-bit character using the Unicodeencoding scheme short-A16-bit(2-byte)integer value int-A32-bit(4-byte)integer value long-A64-bit(8-byte)integer value float-A32-bit(4-byte)floating-point value double-A64-bit(8-byte)floating-point value |
Типы объектов
Примитивные типы также входят в версии, которые являются полноценными объектами. Это означает, что можно:
- ссылаться на них через ссылку на объект;
- давать несколько ссылок на одно и то же значение;
- вызывать методы для них, как и для любого другого объекта.
Список основных из них.
| Формат | Описание |
| Boolean | A binary value of either or |
| Byte | 8 bit signed value, values from -128 to 127 |
| Short | 16 bit signed value, values from -32.768 to 32.767 |
| Character | 16 bit Unicode character |
| Integer | 32 bit signed value, values from -2.147.483.648 to 2.147.483.647 |
| Long | 64 bit signed value, values from -9.223.372.036.854.775.808 to 9.223.372.036.854.775.808 |
| Float | 32 bit floating point value |
| Double | 64 bit floating point value |
| String | N byte Unicode string of textual data. Immutable |
Также можете создавать свои собственные более сложные типы данных, классы.
Объявление:
Integer myInteger;
Когда объявляете переменную ссылки, она не указывает ни на один из них, т.к. сначала нужно создать (экземпляр) его. Вот как это делается:
Integer myInteger; myInteger = new Integer(45);
В этом примере переменная myInteger ссылается на объект Integer, который внутренне содержит 45. Именно новая часть Integer(45) кода создает Integer.
Создание при объявленной переменной:
Integer myInteger = new Integer(45);
Выделение памяти
Коротко о том, как происходит выделение памяти со стороны кода в фоновом режиме:
- Каждый раз при создании объекта в Java он сохраняется в heap памяти.
- Примитивы и локальные переменные хранятся в stack памяти, переменные-члены — в heap.
- При многопоточности каждый поток имеет собственный stack, но находится в общей куче (heap). О многопоточности поговорим во второй части.
- При вызове какого-либо метода все методы и переменные помещаются в stack. По завершении вызова указатель стека (stack) уменьшается.
- 32-разрядная операционка тратит не более 4GB RAM на Java-приложения. В 64-разрядной затраты памяти на те же элементы увеличиваются вдвое.
- Примитивный тип int тратит в 4 раза меньше памяти, чем Integer.
Графическое представление распределения памяти
Таблица ниже перечисляет различные типы данных и их диапазоны хранимых значений:
Типы данных и диапазоны значений
Ссылочные [ править ]
Ссылочные типы — это все остальные типы: классы, перечисления и интерфейсы, например, объявленные в стандартной библиотеке Java, а также массивы.
Строки
Строки это объекты класса String, они очень распространены, поэтому в некоторых случаях обрабатываются отлично от всех остальных объектов. Строковые литералы записываются в двойных кавычках.
Эта программа выведет: Hello World foo == bar ? true foo равен bar ? true foo == baz ? false foo равен baz ? true
Обертки
Если требуется создать ссылку на один из примитивных типов данных, необходимо использовать соответствующий класс-обертку. Также в таких классах есть некоторые полезные методы и константы, например минимальное значение типа int можно узнать использовав константу Integer.MIN_VALUE. Оборачивание примитива в объект называется упаковкой (boxing), а обратный процесс распаковкой (unboxing).
| Тип | Класс-обертка |
|---|---|
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| char | Character |
| float | Float |
| double | Double |
| boolean | Boolean |
Рекомендуется использовать valueOf, он может быть быстрее и использовать меньше памяти потому что применяет кэширование, а конструктор всегда создает новый объект.
Получить примитив из объекта-обертки можно методом Value.
Primitive Data Types
A primitive data type specifies the size and type of variable values, and it has no
additional methods.
There are eight primitive data types in Java:
| Data Type | Size | Description |
|---|---|---|
| byte | 1 byte | Stores whole numbers from -128 to 127 |
| short | 2 bytes | Stores whole numbers from -32,768 to 32,767 |
| int | 4 bytes | Stores whole numbers from -2,147,483,648 to 2,147,483,647 |
| long | 8 bytes | Stores whole numbers from -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807 |
| float | 4 bytes | Stores fractional numbers. Sufficient for storing 6 to 7 decimal digits |
| double | 8 bytes | Stores fractional numbers. Sufficient for storing 15 decimal digits |
| boolean | 1 bit | Stores true or false values |
| char | 2 bytes | Stores a single character/letter or ASCII values |
Диапазоны значений и знак целочисленных типов данных
Как вы уже знаете из предыдущего урока, переменная с n-ным количеством бит может хранить 2n возможных значений. Но что это за значения? Это значения, которые находятся в диапазоне. Диапазон — это значения от и до, которые может хранить определенный тип данных. Диапазон целочисленной переменной определяется двумя факторами: её размером (измеряется в битах) и её знаком (который может быть signed или unsigned).
Целочисленный тип signed (со знаком) означает, что переменная может содержать как положительные, так и отрицательные числа. Чтобы объявить переменную как signed, используйте ключевое слово :
signed char c;
signed short s;
signed int i;
signed long l;
signed long long ll;
|
1 |
signedcharc; signedshorts; signedinti; signedlongl; signedlonglongll; |
По умолчанию, ключевое слово пишется перед типом данных.
1-байтовая целочисленная переменная со знаком (signed) имеет диапазон значений от -128 до 127, т.е. любое значение от -128 до 127 (включительно) может храниться в ней безопасно.
В некоторых случаях мы можем заранее знать, что отрицательные числа в программе использоваться не будут. Это очень часто встречается при использовании переменных для хранения количества или размера чего-либо (например, ваш рост или вес не может быть отрицательным).
Целочисленный тип unsigned (без знака) может содержать только положительные числа. Чтобы объявить переменную как unsigned, используйте ключевое слово :
unsigned char c;
unsigned short s;
unsigned int i;
unsigned long l;
unsigned long long ll;
|
1 |
unsignedcharc; unsignedshorts; unsignedinti; unsignedlongl; unsignedlonglongll; |
1-байтовая целочисленная переменная без знака (unsigned) имеет диапазон значений от 0 до 255.
Обратите внимание, объявление переменной как unsigned означает, что она не сможет содержать отрицательные числа (только положительные). Теперь, когда вы поняли разницу между signed и unsigned, давайте рассмотрим диапазоны значений разных типов данных:
Теперь, когда вы поняли разницу между signed и unsigned, давайте рассмотрим диапазоны значений разных типов данных:
| Размер/Тип | Диапазон значений |
| 1 байт signed | от -128 до 127 |
| 1 байт unsigned | от 0 до 255 |
| 2 байта signed | от -32 768 до 32 767 |
| 2 байта unsigned | от 0 до 65 535 |
| 4 байта signed | от -2 147 483 648 до 2 147 483 647 |
| 4 байта unsigned | от 0 до 4 294 967 295 |
| 8 байтов signed | от -9 223 372 036 854 775 808 до 9 223 372 036 854 775 807 |
| 8 байтов unsigned | от 0 до 18 446 744 073 709 551 615 |
Для математиков: Переменная signed с n-ным количеством бит имеет диапазон от -(2n-1) до 2n-1-1. Переменная unsigned с n-ным количеством бит имеет диапазон от 0 до (2n)-1.
Для нематематиков: Используем таблицу
Начинающие программисты иногда путаются между signed и unsigned переменными. Но есть простой способ запомнить их различия. Чем отличается отрицательное число от положительного? Правильно! Минусом спереди. Если минуса нет, значит число — положительное. Следовательно, целочисленный тип со знаком (signed) означает, что минус может присутствовать, т.е. числа могут быть как положительными, так и отрицательными. Целочисленный тип без знака (unsigned) означает, что минус спереди отсутствует, т.е. числа могут быть только положительными.
Оператор instanceof
Есть ещё один оператор, который возвращает булево значение, — это instanceof.
Он проверяет принадлежность переменной к какому-то классу.
Когда используют instanceof?
Если классы объектов нужно узнать во время выполнения программы.
Допустим, есть два потока исполнения. В первом создаются объекты разных классов, а в другом они используются. С instanceof легко выяснять класс каждого объекта, который получает второй поток.
Класс объекта важно знать и для приведения типов. Хотя большинство подобных проблем выявляет компилятор, но приведение типов при иерархии классов чревато ошибками, которые всплывают только во время работы
Вообще, instanceof используется редко, потому что обычно типы объектов известны сразу. Применять этот оператор считается дурным тоном, это признак плохой программной архитектуры. Но его используют в обобщённых процедурах, которые оперируют объектами из сложной иерархии классов.
Как работать с instanceof
Рассмотрим на примере:
Объект c принадлежит только к классу C. Нам пришлось привести его к классу Object, чтобы можно было проверить на соответствие классу A.
Иначе компилятор сразу бы увидел, что объект класса C не принадлежит к классу A, — и не дал бы запустить программу с ошибкой несовместимости типов:
Упрощённый оператор instanceof в Java 15
Раньше был допустим только такой синтаксис:
То есть мы сначала проверяем, что object может быть приведён к какому-то типу Type, — это и делает оператор instanceof, а внутри условия приводим объект к этому типу и записываем результат в новую переменную.
В Java 15 появилась конструкция упрощённого приведения:
Инициализация переменных
У всех переменных из моих примеров уже было присвоено начальное значение. Процесс присвоения начального значения называется инициализацией переменной. И не обязательно инициализировать переменную во время ее объявления. Java позволяет сделать это и позже.
Во-первых, можно объявлять переменные через запятую (если они одинакового типа):
При этом, смотрите, мы можем некоторые из них инициализировать прямо во время объявления. А теперь инициализируем оставшиеся:
Для инициализации переменных типа я использовал цепочку присваиваний. Да, и так тоже можно. Хотя используется очень редко. Если мы попытаемся провести какую-то операция с переменной, у которой нет значения, то получим ошибку.
Оператор присваивания
Важно запомнить, что если вы где-то в коде Java, а также во многих других языках, увидите знак равенства , вы должны понимать, что это не сравниваются два значения. Вы должны понимать что это оператор присваивания
Его задача: взять значение, которое стоит справа от него, и записать в память переменной, которая стоит слева от него, или другими словами присвоить. Важно, чтобы значения справа и слева были одного типа данных в противном случае получаем ошибку.
⇑
7. Пример описания и использования переменных с плавающей запятой.
float f; // переменная с именем f типа float f = 3.998f; // переменной f присвоить значение 3.998 double d; // переменная с именем d типа double d = -340.349489287; float ff = -3.99f; // инициализация переменной ff типа float double dd = 779303028.3398; // инициализация переменной dd типа double
8. Какие особенности применения символьного типа данных char?
В Java для представления символов введен тип данных char.
Переменные типа char занимают в памяти компьютера 16 бит. Это связано с тем, что для представления символов char в Java используется кодировка Юникод (Unicode). Диапазон допустимых значений этого типа составляет от до 65535.
Использование кодировки Unicode связано с тем, что программы на Java используются во всем мире, то есть в странах, где для представления символа нужно 2 байта (16 бит). Такими странами есть, например, Япония, Китай.
9. Примеры описания и использования переменных типа char
char c; // переменная с именем c типа char c = 'Z'; // присвоение литерала 'Z' c = 90; // c = 'Z' c--; // c = 'Y' char cc = '2'; // инициализация переменной cc значением '2'
10. Какое назначение в программах имеет тип boolean?
Тип boolean предназначен для сохранения логических значений. Переменные типа boolean могут принимать только два значения: true или false.
Пример использования переменных типа boolean.
boolean b; b = true; boolean bb=false; // bb = false bb = 5>4; // bb = true bb = 55==6; // bb = false
11. Какие отличия между примитивными типами и типами-ссылками?
Между примитивными типами и типами-ссылками существуют следующие отличия:
- переменная примитивного типа не является переменной-ссылкой (объектом);
- переменная примитивного типа есть «автоматической» и сохраняется в стеке. Объект (переменная) сохраняется в «куче». Поэтому производительность работы с переменными примитивного типа выше;
- при объявлении переменной примитивного типа не нужно выделять память оператором new;
- переменная примитивного типа напрямую сохраняет свое значение в отличие от переменной-ссылки.
12. Существуют ли беззнаковые примитивные типы?
Нет. В языке Java все примитивные типы являются знаковыми, то есть, могут принимать отрицательные значения.
- Литералы. Идентификаторы. Ключевые слова. Комментарии
- Переменные. Объявление переменных. Инициализация переменных
- Преобразование и приведение типов. Автоматическое продвижение типов в выражениях
Иерархии параметризованных классов
Параметризованные классы могут быть частью иерархии классов так же, как и любые другие не параметризованные классы. То есть параметризованный класс может выступать в качестве супер класса или подкласса.
Ключевое отличие между параметризованными и не параметризованными иерархиями состоит в том, что в параметризованной иерархии любые аргументы типов, необходимые параметризованному супер классу, всеми подклассами должны передаваться по иерархии вверх.
Например:
Подкласс параметризованного супер класса необязательно должен быть параметризованным, но в нем все же должны быть, указаны параметры типа, требующиеся его параметризованному супер классу. Подкласс может, если требуется, быть, дополнен и своими параметрами типа. Супер классом для параметризованного класса может быть класс не параметризованный.
Используя Символы подчеркивания в Числовых Литералах
В Java SE 7 и позже, любое число символов подчеркивания () может появиться где угодно между цифрами в числовом литерале. Эта опция позволяет Вам, например. разделить группы цифр в числовых литералах, которые могут улучшить удобочитаемость Вашего кода.
Например, если Ваш код содержит числа со многими цифрами, можно использовать символ подчеркивания, чтобы разделить цифры в группах три, подобный тому, как Вы использовали бы знак препинания как запятая, или пространство, как разделитель.
Следующий пример показывает другие способы, которыми можно использовать подчеркивание в числовых литералах:
long creditCardNumber = 1234_5678_9012_3456L; long socialSecurityNumber = 999_99_9999L; float pi = 3.14_15F; long hexBytes = 0xFF_EC_DE_5E; long hexWords = 0xCAFE_BABE; long maxLong = 0x7fff_ffff_ffff_ffffL; byte nybbles = 0b0010_0101; long bytes = 0b11010010_01101001_10010100_10010010;
Можно поместить подчеркивания только между цифрами; невозможно поместить подчеркивания в следующие места:
- Вначале или конец числа
- Смежный с десятичной точкой в литерале с плавающей точкой
- До или суффикс
- В позициях, где строка цифр ожидается
Следующие примеры демонстрируют допустимые и недопустимые размещения подчеркивания (которые выделяются) в числовых литералах:
// Invalid: cannot put underscores // adjacent to a decimal point float pi1 = 3_.1415F; // Invalid: cannot put underscores // adjacent to a decimal point float pi2 = 3._1415F; // Invalid: cannot put underscores // prior to an L suffix long socialSecurityNumber1 = 999_99_9999_L; // This is an identifier, not // a numeric literal int x1 = _52; // OK (decimal literal) int x2 = 5_2; // Invalid: cannot put underscores // At the end of a literal int x3 = 52_; // OK (decimal literal) int x4 = 5_______2; // Invalid: cannot put underscores // in the 0x radix prefix int x5 = 0_x52; // Invalid: cannot put underscores // at the beginning of a number int x6 = 0x_52; // OK (hexadecimal literal) int x7 = 0x5_2; // Invalid: cannot put underscores // at the end of a number int x8 = 0x52_;
Что такое Generics в Java?
Дженерики в Java – это термин, обозначающий набор языковых возможностей, связанных с определением и использованием общих типов и методов. Общие методы Java отличаются от обычных типов данных и методов. До Generics мы использовали коллекцию для хранения любых типов объектов, т.е. неуниверсальных. Теперь Generics заставляет программиста Java хранить объекты определенного типа.
Если вы посмотрите на классы платформы Java-коллекции, то увидите, что большинство классов принимают параметр / аргумент типа Object. По сути, в этой форме они могут принимать любой тип Java в качестве аргумента и возвращать один и тот же объект или аргумент. Они в основном неоднородны, т.е. не похожего типа.
Иногда в приложении Java тип данных ввода не является фиксированным. Входными данными могут быть целое число, число с плавающей запятой или строка. Чтобы назначить ввод переменной правильного типа данных, необходимо было провести предварительные проверки.
В традиционном подходе после получения ввода проверяется тип данных ввода, а затем назначается переменная правого типа данных. При использовании этой логики длина кода и время выполнения были увеличены. Чтобы избежать этого, были введены дженерики.
Когда вы используете Generics, параметры в коде автоматически проверяются во время компиляции, и он устанавливает тип данных по умолчанию. Так что это то место, где вам нужна концепция обобщений в Java.
Существует 4 различных способа применения:
- Типовой класс
- Интерфейс
- Метод
- Конструктор
Обновлённый оператор switch в Java 14
С версии 14 Java поддерживает новый синтаксис switch:
Теперь нам не нужно писать break, а двоеточие заменено на стрелочку и фигурные скобки. Блок default по-прежнему не обязателен.
Если код блока case состоит всего из одной строки, то фигурные скобки можно не использовать:
В операторе switch прошлой версии мы задавали одно действие для нескольких значений case, располагая пустые case над case c кодом:
В новой версии для этого хватает одного case, а связанные с ним значения разделяются запятой. Например:
Теперь switch — уже не просто оператор ветвления, он может вернуть значение. Это делается с помощью вспомогательного оператора yield.
Пример:
В новой версии switch, когда нам нужно лишь вернуть значение из соответствующего case (он должен быть без кода), — можно обойтись и без слова yield:
Советы и упрощения
1. Фигурные скобки после if или else разрешено не ставить, если тело блока состоит всего из одной строки.
Однако всё же советую ставить скобки, так вы научитесь быть последовательными и облегчите рефакторинг кода.
2
Вот так писать не следует (внимание на условие в if):. Код будет работать, но сравнение boolean с boolean в условии — это лишняя операция
Код будет работать, но сравнение boolean с boolean в условии — это лишняя операция.
Поскольку метод isMoreFive сам возвращает булево значение — напишите вот так:
Здесь снова ненужное сравнение:
Чтобы не было лишней операции — пишите вот так:
Методы класса
В начале статьи я упомянул, что наши домашние животные могут перемещаться и есть. В отличие от параметров вроде веса и клички, это уже не свойства объекта, а его функции. В классе эти функции обозначают как методы.
Метод класса — это блок кода, состоящий из ряда инструкций, который можно вызывать по его имени. Он обязательно содержит возвращаемый тип, название, аргументы и тело метода.
Синтаксис метода в Java:
Строка возвращаемыйТип показывает, какого типа данные вернёт метод. Например, если в качестве возвращаемого типа мы поставим тип String, то метод должен будет вернуть строку, а если int — целое число.
Чтобы вернуть значение из метода, используется специальное слово return. Если мы хотим, чтобы метод ничего не возвращал, то вместо возвращаемого типа нужно использовать специальное слово void.
Аргументы — то, что нужно передать в метод при его вызове. Мы можем указать сколько угодно параметров через запятую либо не указывать ни одного.
Для примера напишем простейший метод с именем sum (пока что не в нашем классе Pet), который складывает два переданных числа и возвращает их результат:
Возвращаемый тип метода int, он указан перед именем sum. Далее идут два аргумента a и b, у обоих также указан тип int
Важно помнить, что возвращаемый тип и тип переменных не обязательно должны совпадать
Аргументы метода работают как обычные переменные — за пределами метода к ним никак нельзя получить доступ. Внутри метода мы складываем значения из переменных a и b, записываем полученное значение в переменную c. После этого мы возвращаем значение переменной c — только оно доступно вне метода.
Вот пример:
Мы передали в метод sum два значения 1 и 2, а на выходе получили результат их сложения 3. Также можно создать метод, который принимает значение типа String, а возвращает длину этой строки:
В этом случае у нас возвращаемый типа int, а параметр str — типа String.
Попробуем использовать этот метод:
Также мы можем создать метод, который ничего не возвращает, а просто печатает переданное слово в консоль:
Либо метод, который ничего не принимает на вход, а просто печатает «Привет!»:
В методах, которые ничего не возвращают, слово return можно опустить.
Обратите внимание, что return полностью прекращает выполнение метода:
Теперь попробуем вызвать этот метод, передав в него число 3:
В этом случае мы ничего не увидим в консоли, так как 3 меньше 5, а значит, отработает блок if и произойдёт выход из метода с помощью слова return.
Но если передадим 6, увидим нашу надпись «Привет!»:
Методы
Последнее обновление: 17.04.2018
Если переменные и константы хранят некоторые значения, то методы содержат собой набор операторов, которые выполняют определенные действия.
Общее определение методов выглядит следующим образом:
тип_возвращаемого_значения название_метода (){
// тело метода
}
Модификаторы и параметры необязательны.
По умолчанию главный класс любой программы на Java содержит метод main, который служит точкой входа в программу:
public static void main(String[] args) {
System.out.println("привет мир!");
}
Ключевые слова и являются модификаторами. Далее идет тип возвращаемого значения.
Ключевое слово указывает на то, что метод ничего не возвращает.
Затем идут название метода — main и в скобках параметры метода — . И в фигурные скобки заключено тело метода — все действия,
которые он выполняет.
Создадим еще несколько методов:
public class Program{
public static void main (String args[]){
}
void hello(){
System.out.println("Hello");
}
void welcome(){
System.out.println("Welcome to Java 10");
}
}
Здесь определены два дополнительных метода: hello и welcome, каждый из которых выводит некоторую строку на консоль. Методы определяются внутри класса — в данном случае внутри класса Program,
в котором определен метод main.
Но если мы скомпилируем и запустим данную программу, то мы ничего не увидим на консоли. В примере выше мы определили два метода, но мы их нигде не вызываем. По умолчанию в программе Java
выполняется только метод main и все его содержимое. Поэтому, если мы хотим, чтобы другие методы тоже выполнялись, их надо вызвать в методе main.
Вызов метода осуществляется в форме:
имя_метода(аргументы);
После имени метода указываются скобки, в которых перечисляются аргументы — значения для параметров метода.
Например, определим и выполним несколько методов:
public class Program{
public static void main (String args[]){
hello();
welcome();
welcome();
}
static void hello(){
System.out.println("Hello");
}
static void welcome(){
System.out.println("Welcome to Java 10");
}
}
В методе main вызывается один раз метод hello и два раза метод welcome. В этом и заключается одно из преимуществ методов: мы можем вынести некоторые общие действия в
отдельный метод и затем вызывать многократно их в различных местах программы. Поскольку оба метода не имеют никаких параметров, то после их названия при вызове ставятся пустые скобки.
Также следует отметить, что чтобы вызвать в методе main другие методы, которые определены в одном классе с методом main, они должны иметь модификатор
.
В итоге после компиляции и выполнения программы мы увидим на консоли:
Hello Welcome to Java 10 Welcome to Java 10
НазадВперед
Класс Object и его методы
Последнее обновление: 21.04.2018
Хотя мы можем создать обычный класс, который не является наследником, но фактически все классы наследуются от класса Object.
Все остальные классы, даже те, которые мы добавляем в свой проект, являются неявно производными от класса Object.
Поэтому все типы и классы могут реализовать те методы, которые определены в классе Object. Рассмотрим эти методы.
toString
Метод служит для получения представления данного объекта в виде строки. При попытке вывести строковое представления
какого-нибудь объекта, как правило, будет выводиться полное имя класса. Например:
public class Program{
public static void main(String[] args) {
Person tom = new Person("Tom");
System.out.println(tom.toString()); // Будет выводить что-то наподобие Person@7960847b
}
}
class Person {
private String name;
public Person(String name){
this.name=name;
}
}
Полученное мной значение (в данном случае ) вряд ли может служить хорошим строковым описанием объекта.
Поэтому метод нередко переопределяют. Например:
public class Program{
public static void main(String[] args) {
Person tom = new Person("Tom");
System.out.println(tom.toString()); // Person Tom
}
}
class Person {
private String name;
public Person(String name){
this.name=name;
}
@Override
public String toString(){
return "Person " + name;
}
}
Метод hashCode
Метод hashCode позволяет задать некоторое числовое значение, которое будет соответствовать данному объекту или его хэш-код.
По данному числу, например, можно сравнивать объекты.
Например, выведем представление вышеопределенного объекта:
Person tom = new Person("Tom");
System.out.println(tom.hashCode()); // 2036368507
Но мы можем задать свой алгоритм определения хэш-кода объекта:
class Person {
private String name;
public Person(String name){
this.name=name;
}
@Override
public int hashCode(){
return 10 * name.hashCode() + 20456;
}
}
Получение типа объекта и метод getClass
Метод позволяет получить тип данного объекта:
Person tom = new Person("Tom");
System.out.println(tom.getClass()); // class Person
Метод equals
Метод equals сравнивает два объекта на равенство:
public class Program{
public static void main(String[] args) {
Person tom = new Person("Tom");
Person bob = new Person("Bob");
System.out.println(tom.equals(bob)); // false
Person tom2 = new Person("Tom");
System.out.println(tom.equals(tom2)); // true
}
}
class Person {
private String name;
public Person(String name){
this.name=name;
}
@Override
public boolean equals(Object obj){
if (!(obj instanceof Person)) return false;
Person p = (Person)obj;
return this.name.equals(p.name);
}
}
Метод equals принимает в качестве параметра объект любого типа, который мы затем приводим к текущему, если они являются объектами
одного класса.
Оператор instanceof позволяет выяснить, является ли переданный в качестве параметра объект объектом определенного класса,
в данном случае класса Person. Если объекты принадлежат к разным классам, то их сравнение не имеет смысла, и возвращается значение false.
Затем сравниваем по именам. Если они совпадают, возвращаем true, что будет говорить, что объекты равны.
НазадВперед
Структуры данных
Комбинирование хеш-таблиц
Комбинирование двух хеш-таблиц вручную через цикл очень неэффективно. Вот альтернативное решение этой проблемы, которое вам возможно понравится:
Array или ArrayList?
Выбор между и зависит от специфики задачи Java, которую вы хотите решить. Запомните следующие особенности этих типов:
- Массив имеет фиксированный размер, и память для него выделяется во время объявления, а размер может динамически меняться.
- Массивы Java работают намного быстрее, а в намного проще добавлять и удалять элементы.
- При работе с скорее всего возникнет ошибка .
- может быть только одномерным, когда массивы Java могут быть многомерными.
