Kotlin. Базовые типы. Числовые литералы. Числовые константы

Базовые типы. Числовые литералы. Числовые константы. Примеры


Содержание


Поиск на других ресурсах:

1. Классификация базовых типов

Чтобы использовать в программе некоторую переменную (объект), нужно правильно описать тип этой переменной. Согласно описанному типу определяется назначение переменной в программе. В языке Kotlin выделено 5 видов базовых типов:

  • числовые типы (числа)
  • логический тип Boolean;
  • символьный тип Char;
  • строчный тип String;
  • массив Array.

 

2. Классификация числовых типов. Характеристики типов

Среди базовых типов наибольшим множеством представлены числовые типы, которые делятся на две группы:

  • целочисленные типы Byte, Short, Int, Long;
  • типы с плавающей запятой (вещественные типы) Float, Double.

 

2.1. Целочисленные типы

В нижеследующей таблице представлены характеристики целочисленных типов.

Kotlin. Характеристики целочисленных типов

 

Если в программе фигурирует целое число (литерал), то для него действуют следующие правила:

  • если значение числа не превышает диапазон значений типа Int, то тип этого этого числа устанавливается как Int;
  • если значение числа превышает диапазон значений типа Int, то тип этого числа устанавливается как Long.

Если нужно любое целое число (даже небольшое) установить как число типа Long, то к этому числу прибавляется суффикс L. Например 23L, 232323L, 1000023939L.

Примеры целочисленных литералов

25L
288
-3203
-209320302233L

 

2.2. Типы с плавающей запятой

Для чисел с плавающей запятой характерна следующая таблица.

Kotlin. Типы с плавающей запятой Float, Double

Согласно стандарту 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

 


Связанные темы