Базовые типы. Числовые литералы. Числовые константы. Примеры
Содержание
- 1. Классификация базовых типов
- 2. Классификация числовых типов. Характеристики типов
- 3. Примеры объявления и использования целочисленных типов
- 4. Примеры объявления и использования типов с плавающей запятой
- 5. Представление числовых констант в шестнадцатеричной системе исчисления
- 6. Представление числовых констант (литералов) в двоичной системе исчисления
- 7. Представление числовых констант в более читабельной форме. Символ ‘_’
- 8. Константы MIN_VALUE, MAX_VALUE. Допустимые пределы числовых типов
- 9. Вывод допустимых значений типов с плавающей запятой. Пример
- 10. Пример использования беззнаковых целых типов. Вывод допустимых значений беззнаковых типов
- Связанные темы
Поиск на других ресурсах:
1. Классификация базовых типов
Чтобы использовать в программе некоторую переменную (объект), нужно правильно описать тип этой переменной. Согласно описанному типу определяется назначение переменной в программе. В языке Kotlin выделено 5 видов базовых типов:
- числовые типы (числа)
- логический тип Boolean;
- символьный тип Char;
- строчный тип String;
- массив Array.
⇑
2. Классификация числовых типов. Характеристики типов
Среди базовых типов наибольшим множеством представлены числовые типы, которые делятся на две группы:
- целочисленные типы Byte, Short, Int, Long;
- типы с плавающей запятой (вещественные типы) Float, Double.
⇑
2.1. Целочисленные типы
В нижеследующей таблице представлены характеристики целочисленных типов.
Если в программе фигурирует целое число (литерал), то для него действуют следующие правила:
- если значение числа не превышает диапазон значений типа Int, то тип этого этого числа устанавливается как Int;
- если значение числа превышает диапазон значений типа Int, то тип этого числа устанавливается как Long.
Если нужно любое целое число (даже небольшое) установить как число типа Long, то к этому числу прибавляется суффикс L. Например 23L, 232323L, 1000023939L.
Примеры целочисленных литералов
25L 288 -3203 -209320302233L
⇑
2.2. Типы с плавающей запятой
Для чисел с плавающей запятой характерна следующая таблица.
Согласно стандарту IEEE 754 для чисел с плавающей запятой характерны следующие утверждения:
- тип Float обеспечивает одинарную точность;
- тип Double обеспечивает двойную точность.
Разделителем разрядов в числах с плавающей запятой выступает символ ‘.’ (точка).
Примеры чисел с плавающей запятой
28.5 - тип Double 188.323F - тип Float 22.0f - тип Float
⇑
3. Примеры объявления и использования целочисленных типов
Пример 1. Возведение в квадрат переменной целого типа Int.
fun main(args: Array<String>) { // Возведение в квадрат переменной целого типа // 1. Объявить переменную типа Int val n : Int // 2. Ввод n print("n = ") n = readLine().toString().toInt() // 3. Вычислить n*n val square_n = n*n // 4. Вывести результат println("n*n = " + square_n) }
Результат выполнения программы
n = 35 n*n = 1225
Пример 2. Возвести число n в степень 5 и вывести результат. Используются типы Int, Long.
fun main(args: Array<String>) { // Возведение числа в степень 5 // 1. Объявить переменные типа Int та Long val n : Int val res : Long // Результат // 2. Ввод n print("n = ") n = readLine().toString().toInt() // 3. Вычислить n^5 val pow5 : Long pow5 = n.toLong()*n.toLong()*n.toLong()*n.toLong()*n.toLong() // 4. Вывести результат println("n^5 = " + pow5) // n^5 = 10000000000 }
⇑
4. Примеры объявления и использования типов с плавающей запятой
Пример 1. Программа вычисления площади круга по введенному радиусу. Демонстрация использования типа Float.
// Подключить математическую библиотеку. // Нужно для использования константы PI import kotlin.math.* fun main(args: Array<String>) { // Программа вычисления площади окружности по введенному радиусу // 1. Объявить переменные var s:Float // искомая площадь var r:Float // радиус // 2. Ввести радиус print("r = ") r = readLine().toString().toFloat() // 3. Вычислить площадь s = (PI*r*r).toFloat() // 4. Вывести результат println("s = " + s) }
Пример 2. Программа вычисления корней квадратного уравнения. В качестве базового, использован тип Double. В программе вводятся коэффициенты уравнения a, b, c.
fun main(args: Array<String>) { // Вычислить корни квадратного уравнения // 1. Объявить переменные типа Double val a:Double val b:Double val c:Double val D:Double val x1:Double val x2:Double // 2. Ввод a, b, c print("a = ") a = readLine().toString().toDouble() print("b = ") b = readLine().toString().toDouble() print("c = ") c = readLine().toString().toDouble() // 3. Вычислить дискриминант D = b*b-4*a*c // 4. Вычислить корни if (D<0) println("The equation has no roots.") else { // Использовать функцию kotlin.math.sqrt() x1 = (-b-kotlin.math.sqrt(D))/(2*a) x2 = (-b+kotlin.math.sqrt(D))/(2*a) println("x1 = " + x1) println("x2 = " + x2) } }
Результат выполнения программы
a = 1 b = 1 c = -2 x1 = -2.0 x2 = 1.0
⇑
5. Представление числовых констант в шестнадцатеричной системе исчисления
Целочисленные константы могут быть представлены в системе исчисления с основанием 16. В этой системе исчисления для обозначения числа используются:
- цифры от 0 до 9;
- буквы латинского алфавита A, B, C, D, E, F или a, b, c, d, e, f.
Каждая шестнадцатеричная константа начинается с пары символов 0x.
Пример. Объявление целочисленных констант в шестнадцатеричной системе счисления
val h1 = 0x0A5 // h1 = 165 val h2 = 0x0f8 // h2 = 248
В десятичной системе исчисления значение h1 равно 165. Так же значение h2 равно 248.
⇑
6. Представление числовых констант (литералов) в двоичной системе исчисления
Целочисленные константы могут быть представлены в двоичной системе исчисления. Чтобы отличить двоичную систему исчисления каждая из констант начинается с пары символов 0b или 0B. Учитывая, что константы в двоичной системе, то значение цифр могут быть 0 или 1.
Пример.
// Константа в двоичной системе исчисления val max = 0b11111111 // max = 255 в десятичной системе println("max = " + max) val min = 0B1000 // min = 8 println("min = " + min)
Нижеприведенный код вызовет ошибку «The value is out of range»
val errorValue = 0b00213 // Ошибка - только цифры 0 или 1
⇑
7. Представление числовых констант в более читабельной форме. Символ ‘_’
Если в программе используются числовые константы, имеющие большое количество десятичных знаков, то можно задавать эти константы в удобной форме, разделяя разряды символом ‘_’.
Пример 1. Способы представления числа 1000000000 (один миллиард):
// Обычное представление var tt = 1000000000 // Представление с помощью символа подчеркивания tt = 1_000_000_000 // так удобнее tt = 1000_000_000 // тысячу миллионов tt = 1_000_0_00_0_00 // так тоже можно
Пример 2. Способы представления двоичного числа 15
// Обычное представление var bin_number = 0b1111 // Представление с помощью подчеркивания bin_number = 0b1_1_1_1 bin_number = 0b11_11
⇑
8. Константы MIN_VALUE, MAX_VALUE. Допустимые пределы числовых типов
Для любого числового типа (Int, UByte, Double, …) определены константы MIN_VALUE и MAX_VALUE, содержащие минимально возможное и максимально-возможное значение числового типа.
Например, чтобы определить минимально возможное значение типа Short в программе на языке Kotlin нужно написать следующее выражение
Short.MIN_VALUE
Значение константы Short.MIN_VALUE равно -32768.
Таким же образом можно определить предельные значения любого числового типа: Int, Long, Double, ULong и тому подобное.
⇑
9. Вывод допустимых значений типов с плавающей запятой. Пример
В примере выводятся предельные значения типов Float и Double.
fun main(args: Array<String>) { // Вывести минимальные и максимальные значения типов с плавающей запятой // 1. Тип Float val minFloat : Float val maxFloat : Float minFloat = kotlin.Float.MIN_VALUE maxFloat = Float.MAX_VALUE println("minFloat = " + minFloat) println("maxFloat = " + maxFloat) // 2. Тип Double val minDouble : Double = Double.MIN_VALUE val maxDouble : Double = Double.MAX_VALUE println("minDouble = " + minDouble) println("maxDouble = " + maxDouble) }
Результат выполнения программы
minFloat = 1.4E-45 maxFloat = 3.4028235E38 minDouble = 4.9E-324 maxDouble = 1.7976931348623157E308
⇑
10. Пример использования беззнаковых целых типов. Вывод допустимых значений беззнаковых типов
В примере выводится минимально-допустимое и максимально-допустимое значение беззнаковых типов UByte
fun main(args: Array<String>) { // Вывести минимальное и максимальное значения беззнаковых целых типов // 1. Тип UByte val minUByte : UByte val maxUByte : UByte minUByte = UByte.MIN_VALUE maxUByte = UByte.MAX_VALUE println("Type UByte: min = " + minUByte + ", max = " + maxUByte) // 2. Тип UShort val minUShort : kotlin.UShort // можно и так val maxUShort : UShort minUShort = UShort.MIN_VALUE maxUShort = kotlin.UShort.MAX_VALUE // можно и так println("Type UShort: min = " + minUShort + ", max = " + maxUShort) // 3. Тип UInt val minUInt : UInt = UInt.MIN_VALUE val maxUInt : UInt = UInt.MAX_VALUE println("Type UInt: min = " + minUInt + ", max = " + maxUInt) // 4. Тип ULong val minULong : ULong = ULong.MIN_VALUE val maxULong : ULong = ULong.MAX_VALUE println("Type ULong : min = " + minULong + ", max = " + maxULong) }
Результат выполнения программы
Type UByte: min = 0, max = 255 Type UShort: min = 0, max = 65535 Type UInt: min = 0, max = 4294967295 Type ULong : min = 0, max = 18446744073709551615
⇑
Связанные темы
⇑