Error incompatible types string cannot be converted to int

ошибка: несовместимые типы: String не может быть преобразован в int

Я новичок в программировании и очень новичок в Java, поэтому я уверен, что этот вопрос (и все мои другие ошибки) будет очевиден для любого, у кого есть опыт. Я точно не знаю, что делаю. Моим заданием было преобразовать код Python в Java. Ниже мой код.

Мои два кода ошибки:

Для пояснения я использую JGrasp, но не хочу.

Спасибо за продвинутую помощь.

2 ответа

response — это int , а метод nextLine() из Scanner возвращает . ну, строку, представленную String . Вы не можете назначить String на int — как бы вы это сделали? String может быть любым, от «some text» до » a 5 0 » . Как бы вы преобразовали первый и / или второй в int ?

Вероятно, вы хотели:

Метод nextInt() ожидает последовательность цифр и / или символов, которые могут представлять число, например: 123 , -50 , 0 и так далее .

Однако вы должны знать об одной важной проблеме — смешивание nextLine() и nextInt() может привести к нежелательным результатам. Например:

Напечатает ничего , потому что при вводе числа вы вводите, например, 123 и нажимаете enter , вы дополнительно вводите символ новой строки . Затем nextLine() сработает и просканирует каждый символ до первого введенного символа новой строки или конца файла , который, очевидно, все еще там , не использованный < >. Чтобы исправить это и узнать больше об этом, перейдите здесь

Чтобы прочитать целое число из файла, вы можете просто использовать такой пример:

Однако вы не даете дополнительной информации о своей файловой структуре, поэтому я советую еще раз заглянуть в документацию, чтобы найти то, что вам больше всего подходит. Вы можете найти документацию по сканеру здесь.

Источник

How to Handle the Incompatible Types Error in Java

Table of Contents

Introduction to Data Types & Type Conversion

Variables are memory containers used to store information. In Java, every variable has a data type and stores a value of that type. Data types, or types for short, are divided into two categories: primitive and non-primitive. There are eight primitive types in Java: byte , short , int , long , float , double , boolean and char . These built-in types describe variables that store single values of a predefined format and size. Non-primitive types, also known as reference types, hold references to objects stored somewhere in memory. The number of reference types is unlimited, as they are user-defined. A few reference types are already baked into the language and include String , as well as wrapper classes for all primitive types, like Integer for int and Boolean for boolean . All reference types are subclasses of java.lang.Object [1].

In programming, it is commonplace to convert certain data types to others in order to allow for the storing, processing, and exchanging of data between different modules, components, libraries, APIs, etc. Java is a statically typed language, and as such has certain rules and constraints in regard to working with types. While it is possible to convert to and from certain types with relative ease, like converting a char to an int and vice versa with type casting [2], it is not very straightforward to convert between other types, such as between certain primitive and reference types, like converting a String to an int , or one user-defined type to another. In fact, many of these cases would be indicative of a logical error and require careful consideration as to what is being converted and how, or whether the conversion is warranted in the first place. Aside from type casting, another common mechanism for performing type conversion is parsing [3], and Java has some predefined methods for performing this operation on built-in types.

Incompatible Types Error: What, Why & How?

The incompatible types error indicates a situation where there is some expression that yields a value of a certain data type different from the one expected. This error implies that the Java compiler is unable to resolve a value assigned to a variable or returned by a method, because its type is incompatible with the one declared on the variable or method in question. Incompatible, in this context, means that the source type is both different from and unconvertible (by means of automatic type casting) to the declared type.

This might seem like a syntax error, but it is a logical error discovered in the semantic phase of compilation. The error message generated by the compiler indicates the line and the position where the type mismatch has occurred and specifies the incompatible types it has detected. This error is a generalization of the method X in class Y cannot be applied to given types and the constructor X in class Y cannot be applied to given types errors discussed in [4].

The incompatible types error most often occurs when manual or explicit conversion between types is required, but it can also happen by accident when using an incorrect API, usually involving the use of an incorrect reference type or the invocation of an incorrect method with an identical or similar name.

Incompatible Types Error Examples

Explicit type casting

Assigning a value of one primitive type to another can happen in one of two directions. Either from a type of a smaller size to one of a larger size (upcasting), or from a larger-sized type to a smaller-sized type (downcasting). In the case of the former, the data will take up more space but will be intact as the larger type can accommodate any value of the smaller type. So the conversion here is done automatically. However, converting from a larger-sized type to a smaller one necessitates explicit casting because some data may be lost in the process.

Fig. 1(a) shows how attempting to assign the values of the two double variables a and b to the int variables x and y results in the incompatible types error at compile-time. Prefixing the variables on the right-hand side of the assignment with the int data type in parenthesis (lines 10 & 11 in Fig. 1(b)) fixes the issue. Note how both variables lost their decimal part as a result of the conversion, but only one kept its original value—this is exactly why the error message reads possible lossy conversion from double to int and why the incompatible types error is raised in this scenario. By capturing this error, the compiler prevents accidental loss of data and forces the programmer to be deliberate about the conversion. The same principle applies to downcasting reference types, although the process is slightly different as polymorphism gets involved [5].

Источник

Аннотации типов Python

Python известен как язык Дикого Запада, в котором дозволено всё. Стили кода (если не считать отступы) и документации, по большей части, оставлены на усмотрение разработчика. Но это может привести к некоторому беспорядку и нечитабельности кода.

Частично это связано с тем, что Python — язык с динамической типизацией. Это означает, что типы связаны со значением переменной, а не с ней самой. Таким образом, переменные могут принимать любое значение в любой момент и проверяются только перед выполнением операций над ними.

Рассмотрим следующий код. В Python это вполне приемлемо.

В приведенном выше коде значение age сначала является int , но позже мы меняем его на str . Каждая переменная может представлять любое значение в любой точке программы. В этом сила динамической типизации!

Попробуем сделать то же самое на языке со статической типизацией, например на Java.

Мы получаем следующую ошибку, потому что пытаемся назначить «Twenty One» (строку) переменной age , которая была объявлена ​​как int .

Чтобы тот же функционал работал на языке со статической типизацией, нам пришлось бы использовать две отдельные переменные.

Это приемлемо, но мне очень нравится гибкость Python и, в частности, динамическая типизация, благодаря которой мне не приходится объявлять больше переменных, чем необходимо. Но мне также нравится удобочитаемость статически типизированных языков, ведь так другие программисты знают, какого типа должна быть конкретная переменная! Чтобы получить лучшее из обоих миров, в Python 3.5 были представлены аннотации типов.

От редакции Pythonist. Предлагаем также почитать статью «Проверка типов данных и «утиная» типизация в Python».

Что такое аннотации типов?

Аннотации типов – это новая возможность, описанная в PEP484, которая позволяет добавлять подсказки о типах переменных. Они используются, чтобы информировать читателя кода, каким должен быть тип переменной. Это придаёт немного статический вид коду на динамически типизированном Python. Достигается это синтаксисом: после инициализации / объявления переменной.

Ниже показан пример, в котором при объявлении переменной добавляется : int , чтобы показать, что возраст должен иметь тип int .

Важно отметить, что аннотации типов никоим образом не влияют на время выполнения программы. Эти подсказки игнорируются интерпретатором и используются исключительно для повышения удобочитаемости для других программистов и вас самих.

Зачем и как использовать аннотации типов

Полезной особенностью языков со статической типизацией является то, что тип значения переменной всегда известен. Например, мы знаем, что строковые переменные могут быть только строками, int может быть только целым числом и т. д. С динамически типизированными языками можно только догадываться, каким является или должно быть значение переменной.

Мы можем использовать ожидаемый тип переменной при написании и вызове функций, чтобы обеспечить правильную передачу и использование параметров. Если мы передадим str , когда функция ожидает int , то, скорее всего, она не будет работать так, как мы ожидали.

Рассмотрим следующий код:

Мы видим, что делает эта функция, но знаем ли мы, какими должны быть a , b или times ? Посмотрите на следующий код, особенно на две строки, в которых мы вызываем mystery_combine с разными типами аргументов. Обратите внимание на вывод каждой версии, который показан в комментариях под каждым блоком.

Странно: в зависимости от того, что мы передаем функции, мы получаем два совершенно разных результата. С целыми числами мы получаем вычисления, но когда мы передаем в функцию строки, первые два аргумента объединяются, и эта результирующая строка умножается на times .

Оказывается, написавший функцию разработчик ожидал, что именно вторая версия станет вариантом использования mystery_combine ! Используя аннотации типов, мы можем устранить эту путаницу.

К параметрам функции добавились : str , : str и : int , чтобы показать, какого типа они должны быть. Это должно сделать код более понятным для чтения и лучше раскрыть его предназначение.

Мы также добавили -> str , чтобы показать, что эта функция вернет str . Используя -> , мы можем более легко показать типы возвращаемых значений любой функции или метода, чтобы избавить от возможной путаницы будущих разработчиков!

Функцию все еще можно вызвать неправильно, но, присмотревшись, программист должен понять, как следует ее использовать. Аннотации типов и подсказки невероятно полезны для приложений Python, над которыми работают нескольких разработчиков. Это устраняет большую часть догадок при чтении кода!

Сложные типы

Однако, не всегда всё будет так просто, поэтому давайте разберемся с некоторыми более сложными случаями.

Для чего-то большего, чем примитивные типы в Python, используйте класс typing . В нем описаны типы для аннотирования любой переменной любого типа. Он поставляется с предварительно загруженными аннотациями типов, таких как Dict , Tuple , List , Set и т. д. Затем вы можете расширить подсказки по типу до вариантов использования, как в примере ниже.

Это скажет читателю, что names должен быть списком строк. Словари работают аналогично.

Подсказка типа Dict [str, float] сообщает нам, что оценки должны быть словарем, где ключи являются строками, а значения — числами с плавающей запятой.

В других сложных примерах понадобится модуль typing .

Псевдонимы типов

Если вы хотите работать с пользовательскими именами типов, вы можете использовать псевдонимы типов. Допустим, вы работаете с группой точек [x, y] в виде кортежей. Тогда можно использовать псевдоним для сопоставления типа Tuple с типом Point .

Несколько возвращаемых значений

Если ваша функция возвращает несколько значений в виде кортежа, просто оберните ожидаемый результат вот так: typing.Turple[ , , . ]

Приведенный код возвращает кортеж количества успешных попыток и ошибок при вызове API – оба значения имеют тип int . Используя Tuple[int, int] , мы указываем читателю, что функция действительно возвращает несколько значений int .

Несколько возможных типов возвращаемых значений

Если в вашей функции есть переменная, принимающая значения различных типов, можно использовать типы typing.Optional или typing.Union .

Используйте Optional , если значение будет либо определенного типа, либо исключительно None .

Код, приведенный выше, указывает, что some_num может иметь тип int или None .

Когда значение может принимать более конкретные типы, используйте Union .

Приведенный выше код указывает, что оценка может иметь тип int или str . Это полезно в нашем примере с выводом оценок, так что мы можем вывести 98% или «Девяносто восемь процентов» без каких-либо неожиданных последствий.

Больше примеров

Дополнительные примеры вы можете найти в официальной документации Python о модуле typing – там можно проверить ещё массу различных вариантов использования аннотации типов. В этой cтатье я показал лишь верхушку айсберга, но, надеюсь, вдохновил вас на написание более чистого кода.

Источник

Assignment1.java:37: error: incompatible types: String cannot be
converted to int 
response = reader.nextLine();
Assignment1.java:38: error: incompatible types: int cannot be converted to String 
num = Integer.parseInt(response);

import java.util.Scanner;
public class Assignment1 {
      public static void main(String[] args) {

         int num, response, min, max, range, sum, count, avg;
         Scanner reader = new Scanner(System.in);
         String reportTitle;


         //title
         System.out.println();
         System.out.println("Enter a title for this report");
         reportTitle = reader.nextLine();
         System.out.println();


         //data input
         System.out.println("Enter a series of numebr, ending with a 0");

         num = 0;
         sum = 0;
         response = 1;
         count = 0;
         max = 0;
         min = 0;
         range = 0;

         while (true)
         {
            if (response < 1)
            {
               System.out.println("End of Data");
               break;
            }

          System.out.println("Enter number => ");
          response = reader.nextLine();
          num = Integer.parseInt(response);

          sum += num;
          count += 1;

          if (num>max)
          {
            max = num;
          }
          if (num<min)
          {
            min = num;
          }

         }

         //crunch
         avg = sum / count;
         range = max - min;

         //report
         System.out.println();
         System.out.println(reportTitle);
         System.out.println();
         System.out.println("Sum: => "+sum);
         System.out.println("Average: => "+avg);
         System.out.println("Smallest: => "+min);
         System.out.println("Largest: => "+max);
         System.out.println("Range: => "+range);


    }

}

2 ответа

Лучший ответ

System.out.println("Enter number => ");
response = reader.nextInt();
// notice this        ^^^

System.out.println("Enter number => ");
response = reader.nextLine();
// instead of this    ^^^^

Scanner sc = new Scanner(System.in);
String s;
int a = sc.nextInt();
s = sc.nextLine();
System.out.println(s);

Scanner sc = new Scanner(System.in);
int i = sc.nextInt();

Внутри высокоуровневых языков программирования данные разделяются по типам. Например, строки относятся к типу String, а числа — к типу int.

Зачем нужны типы? Для защиты программы от трудноотловимых ошибок. Типы определяют две вещи:

• Допустимые значения. Например, числа в Java делятся на две группы типов: целые int и рациональные float. Такое разделение связано с техническими особенностями работы аппаратуры.
• Набор допустимых операций. Например, операция умножения имеет смысл для типа «целые числа». Но не имеет смысла для типа «строки»: умножать слово «мама» на слово «блокнот» — бессмыслица.

Язык программирования распознает типы. Поэтому Java не позволит нам умножать строку на строку. Но позволит умножать целое число на другое целое число. Наличие типов и таких ограничений в языке защищает программы от случайных ошибок:

"one" * "two"
Error:
bad operand types for binary operator '*'
    first type:  java.lang.String
    second type: java.lang.String

Каким образом Java понимает, что за тип данных перед ним? Любое значение где-то инициализируется. В зависимости от способа инициализации, становится понятно, что именно находится перед нами.

Например, число — это просто число, не обернутое в кавычки или другие парные символы. А вот строки всегда ограничены двойными кавычками. Например, значение "234"считается строкой, хотя внутри нее записаны цифры:

// Компилятор понимает что тут число
var age = 33;

По-английски строки в программировании называются strings, а строчки текстовых файлов называются lines. Например, в коде выше одна строчка (lines) и ноль строк (strings). В русском языке иногда может быть путаница, поэтому во всех уроках мы будем говорить использовать такие термины:

• Строка — для обозначения типа данных strings
• Строчка — для обозначения lines (строчек в текстовых файлах)

Типов данных в Java много, плюс можно создавать свои. Постепенно мы познакомимся со всеми необходимыми и научимся их правильно использовать.

Явная типизация

До сих пор при определении переменных мы использовали ключевое слово var, что может удивить тех, кто имеет какой-то опыт на Java. Обычно определение переменных показывают так:

int x = 3;
String greeting = "Hello Hexlet!";

// Error: incompatible types: java.lang.String cannot be converted to int
int ops = "test";

Пришло время раскрыть карты! Java — это статически типизированный язык. В таких языках тип переменной фиксируется при ее объявлении. В большинстве языков для этого перед именем переменной указывается ее тип — в примере выше это число (int) и строка (String).

Раньше на Java создавали переменные только так, до тех пор пока не появился var. var – специальное ключевое слово, которое включает механизм вывода типов. Вывод типов автоматически определяет тип присваиваемого значения и связывает его с переменной. В примерах выше очевидно, где какой тип, тогда зачем его явно прописывать?

Вывод типов в Java появился в 2018 году, но в некоторых других язык он существует не один десяток лет. Первый язык с выводом типов называется ML и появился он аж в 1973 году. С тех пор вывод типов был добавлен в Ocaml, Haskell, C#, F#, Kotlin, Scala и множество других языков.

Вывод типов и предпочтителен в большинстве ситуаций, однако бывает такое, что выводимый тип нас не устраивает. Тогда мы можем указать тип явно.

Какие бывают типы

В этом уроке мы рассмотрим систему типов в Java с высоты птичьего полета, не погружаясь в детали. Но сначала ответим на вопрос, зачем вообще про них знать?

В коде мы все время оперируем данными. Эти данные имеют разную природу, могут быть по-разному организованы, что влияет на удобство работы с ними. Типы преследуют нас на каждом шагу, поэтому без них программирование на Java возможно только на очень базовом уровне.

С другой стороны, не пытайтесь запомнить всю эту информацию про типы наизусть — она дается лишь для общего представления. Все важное о типах вы и так выучите в процессе программирования. Глобально, типы данных в Java делятся на две большие группы:

• Примитивные — предопределены в Java
• Ссылочные или не примитивные — создаются самим программистом, за исключением String и Array

У этих групп есть различия, которые мы разберем позже, когда познакомимся с null и объектно-ориентированным программированием. Пока достаточно знать, что имена примитивных типов начинаются с нижнего регистра (int), а ссылочных с верхнего (String).

Всего в Java восемь примитивных типов данных:

• byte
• short
• int
• long
• float
• double
• boolean
• char

Рассмотрим первые четыре типа. Это целые числа разного размера:

• byte — занимает в памяти 1 байт, значит может хранить числа от -128 до 127
• short — занимает в памяти 2 байта
• int — занимает в памяти 4 байта
• long — занимает в памяти 8 байт

Посмотрим на примере такого кода:

byte x = 3; // Отработает без проблем

// Error: incompatible types: possible lossy conversion from int to byte
byte y = 270;

Определение переменной y завершилось с ошибкой, потому что мы указали тип byte, но присвоили переменной значение 270, которое выходит за множество допустимых значений.

Возникает закономерный вопрос. Зачем аж четыре типа для хранения чисел? Почему бы не сделать один, в который влезает почти любое большое число?

Технически так сделать можно, но мы находимся в мире инженерных решений. У любого решения всегда есть обратная сторона, поэтому невозможно сделать идеально — придется чем-то пожертвовать. В данном случае, объемом занимаемой памяти. Если оставить только long, то программа, активно оперирующая числами, начнет занимать слишком много места в оперативной памяти, что может быть критично.

Такая же логика использовалась для типов float и double. Они оба отвечают за рациональные числа. Разница лишь в том, что double — это двойной float, то есть в памяти он занимает в два раза больше места.

Создатели Java полагаются на разумность программистов, на их способность правильно подобрать нужные типы в зависимости от задачи. Для каких-то экстремальных приложений так и происходит, но в типичной разработке все просто. Программисты выбирают int для целых чисел и double для рациональных.

Рассмотрим оставшиеся типы данных.

Тип boolean отвечает за логические значения true и false. Им посвящен целый раздел, там мы про него и поговорим.

Особняком стоит тип char — символ. Это не строка, у него другой способ определения — через одиночные кавычки:

char ch = 'a';

// Error: incompatible types: java.lang.String cannot be converted to char
char ch2 = "b";

Строка, состоящая из одного символа — это не символ. Кажется, нелогично, но с точки зрения типов все так и должно быть, со временем вы это прочувствуете.

Извлечение символа из строки извлекает как раз символ, а не строку, состоящую из одного символа:

"hexlet".charAt(1); // 'e'

Хорошо, а где тип данных String — строка? Дело в том, что она не является примитивным типом. Внутри она представляет собой массив символов. Несмотря на это техническое различие, строки используются наравне с примитивными типами без особых отличий.

Значение по умолчанию

Примитивные данные всегда имеют значение, даже если они определяются без инициализации:

int a;
System.out.println(a); // => 0

У каждого примитивного типа есть свое значение по умолчанию:

byte    0
short   0
int     0
long    0
float   0.0
double  0.0
char    ''
boolean false

Значение null

Особняком в Java стоит значение null. В Java оно не является типом. Это просто конкретное значение со специальным смыслом и логикой работы. Начнем с примера:

// Определение переменной без инициализации значением
// С var такое не сработает, так как невозможно вывести тип
String a;

Что находится внутри переменной a? Если мы ее распечатаем, то увидим null. Значение null используется для ссылочных типов, когда значение не определено.

Как такое возможно? Представьте, что мы хотим извлечь из базы данных пользователя, а его там нет. Что вернет нам запрос в базу? Вот именно для таких ситуаций и нужен null.

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

var user = // тут делаем запрос в базу
// Если данных нет, то user станет null
// Запись выше равносильна
var user = null;

Из вышесказанного следует важный вывод. Любой ссылочный тип данных может принимать значение null. То есть, null является значением любого ссылочного типа. А вот примитивные типы и null не совместимы. Примитивное значение всегда должно быть определено:

// Error: incompatible types: <nulltype> cannot be converted to int
int x = null;

Явное преобразование типов

В программировании регулярно встречаются задачи, когда один тип данных нужно преобразовать в другой. Простейший пример – работа с формами на сайтах.

Данные формы всегда приходят в текстовом виде, даже если значение число. Вот как его можно преобразовать:

// станет int
var number = Integer.parseInt("345");
System.out.println(number); // => 345

Если нужно конвертировать из примитивного типа в примитивный, то все проще. Достаточно перед значением в скобках указать желаемый тип. В результате значение справа преобразуется в значение другого типа, указанного слева:

var result = (int) 5.1;
System.out.println(result); // => 5

Преобразование типов можно использовать внутри составных выражений:

// Дополнительные скобки помогают визуально отделить части выражения друг от друга
var result = 10 + ((int) 5.1);
System.out.println(result); // => 15

Welcome to the Treehouse Community

The Treehouse Community is a meeting place for developers, designers, and programmers of all backgrounds and skill levels to get support. Collaborate here on code errors or bugs that you need feedback on, or asking for an extra set of eyes on your latest project. Join thousands of Treehouse students and alumni in the community today. (Note: Only Treehouse students can comment or ask questions, but non-students are welcome to browse our conversations.)

Looking to learn something new?

Treehouse offers a seven day free trial for new students. Get access to thousands of hours of content and a supportive community. Start your free trial today.

1. 
   Home

2. 
   Software Programming

3. 
   Word Error in Java — «error: incompatible types: String cannot be converted to int»