Error incompatible types object cannot be converted to

Using Kotlin.

I have defined in my root XML data class an element an annotated it with @element

...
  @Element
  var synchronization: Synchronization?,
...

also I have defined a data class Synchronization

@Xml
data class Synchronization(
  @Attribute
  var type: String?,

  @Attribute
  var autosync: Int?,

  @Attribute
  var revision: String?,

  @PropertyElement
  var url: String?,

  @PropertyElement
  var download: String?,

  @PropertyElement
  var upload: String
)

When Android Studio now compiles everything to send it to the device I get following error:

error: incompatible types: Object cannot be converted to Synchronization
Incompatible types. Required: xxx.Synchronization Found: java.lang.Object

In the TypeAdapter of the main XML file there is following code generated and it looks like there is no cast to Synchronization object like in a list.

    childElementBinders.put("synchronization", new ChildElementBinder<ValueHolder>() {
      @Override
      public void fromXml(XmlReader reader, TikXmlConfig config, ValueHolder value) throws
          IOException {
        value.synchronization = config.getTypeAdapter(Synchronization.class).fromXml(reader, config);
      }
    });

For example a list has the needed cast to an account class:

    childElementBinders.put("account", new ChildElementBinder<ValueHolder>() {
      @Override
      public void fromXml(XmlReader reader, TikXmlConfig config, ValueHolder value) throws
          IOException {
        if (value.accounts == null) {
          value.accounts = new ArrayList<Account>();
        }
        value.accounts.add((Account) config.getTypeAdapter(Account.class).fromXml(reader, config) );
      }
    });

Is this a bug or did I miss something?

Код из HeadFirst
Выглядит это так:
/DotComBust.java:5: error: cannot find symbol
private GameHelper helper = GameHelper();//нужные переменные
^
symbol: method GameHelper()
location: class DotComBust
/DotComBust.java:19: error: incompatible types: Object cannot be converted to DotCom
for (DotCom dotComToSet:dotComList){//повторяем с каждым dotcom
^
/DotComBust.java:35: error: incompatible types: Object cannot be converted to DotCom
for (DotCom dotComToTest : dotComList){//сделать это для всех dotcom в списке
^
Note: /DotComBust.java uses unchecked or unsafe operations.
Note: Recompile with -Xlint:unchecked for details.
3 errors

import java.io.*;
import java.util.ArrayList;
import java.util.*;
public class DotComBust{
    private GameHelper helper = GameHelper();//нужные переменные
    private ArrayList dotComList = new ArrayList();//ArrayList только для сайтов
    private int numOfGuesses = 0;
    private void setUpGame(){//создаем сайты и даем им имена
        DotCom one = new DotCom();
        one.setName("Pets.com");
        DotCom two = new DotCom();
        two.setName("eToys.com");
        DotCom three = new DotCom();
        three.setName("Go2.com");
        dotComList.add(one);//помещаем их в ArrayList
        dotComList.add(two);
        dotComList.add(three);
        System.out.println("Потопить 3");//инструкции
        for (DotCom dotComToSet:dotComList){//повторяем с каждым dotcom
            ArrayList<String> newLocation = helper.placeDotCom(3);//зарпашиваем у объекта адрес сайта
            dotComToSet.setLocationCells(newLocation);//вызываем сеттер из dotcom
        }//и передаем ему местоположение корабля, которое
    }//только что получили от другого объекта
    private void startPlaying(){
       while(!dotComList.isEmpty()){ //делать это(далее), пока dotcom не опустеет
           String userGuess = helper.getUserInput("Сделайте ход"); //ход пользователя
           checkUserGuess(userGuess); //проверяем на факт попадания
       }
       finishGame();
    }

    private void checkUserGuess(String userGuess){
        numOfGuesses++;//плюс попытка
        String result = "Мимо";//изначально это мимо
        for (DotCom dotComToTest : dotComList){//сделать это для всех dotcom в списке
            result = dotComToTest.checkYourself(userGuess);//проверяем было ли попадание
            if(result.equals("Попал")){//если да, то...
                break;//останавливаем цикл и ждем следующий ход
            }
            if(result.equals("Потопил")){
                dotComList.remove(dotComToTest);//если потоплен, то удаляем
                break;//из списка и останавливаем цикл
            }
        }
        System.out.println(result);//результат выстрела
    }
    private void finishGame(){
        System.out.println("Все сайты на дне, упс");
        if(numOfGuesses <= 18){
            System.out.println("Отлично " + numOfGuesses);//итог всей игры
        } else {
            System.out.println("Плохо " + numOfGuesses);
        }
    }
    public static void main(String[] args){
        DotComBust game = new DotComBust();//создаем игровой объект
        game.setUpGame();//объявляем подготавливаем игру
        game.startPlaying();//начинаем игру
    }
}
class DotCom{
    private ArrayList<String> locationCells;//местоположение
    private String name;//имя сайта
    public void setLocationCells(ArrayList<String> loc){//обновляет местоположение
        locationCells = loc;//сайта, полученый случайно из placeDotCom()
    }
    public void setName(String n){//"Ваш простой сеттер"
        name = n;
    }
    public String checkYourself(String userInput){
        String result = "Мимо";//если есть попадание, то indexOf вернет его местоположение
        int index = locationCells.indexOf(userInput);//если мимо, то вернет -1
        if (index >= 0){//если попал, то удаляем ячейку по индексу
            locationCells.remove(index);
            if (locationCells.isEmpty()){//если сайт "пуст", то потопил
                result = "Потопил";
                System.out.println("Потоплен " + name);//поздравление
            }else{
                result = "Попал";
            }
        }
        return result;
    }
}
class GameHelper{
    private static final String alphabet = "abcdefg";
    private int gridLength = 7;
    private int gridSize = 49;
    private int [] grid = new int[gridSize];
    private int comCount = 0;
    public String getUserInput(String prompt){
        String inputLine = null;
        System.out.print(prompt + " ");
        try{
            BufferedReader is = new BufferedReader(new InputStreamReader(System.in));
            inputLine = is.readLine();
            if(inputLine.length() == 0) return null;
        }catch(IOException e){
            System.out.println("IOException: " + e);
        }
        return inputLine.toLowerCase();
    }
    public ArrayList<String> placeDotCom(int comSize){
        ArrayList<String> alphaCells = new ArrayList<String>();
        String [] alphacoords = new String [comSize];
        String temp = null;
        int [] coords = new int[comSize];
        int attempts = 0;
        boolean success = false;
        int location = 0;
        comCount++;
        int incr = 1;
        if((comCount % 2) == 1){
            incr = gridLength;
        } 
        while (!success & attempts++ < 200){
            location = (int)(Math.random()*gridSize);
            System.out.print("пробуем " + location);
            int x = 0;
            success = true;
            while (success && x < comSize){
                if(grid[location] == 0){
                    coords[x++] = location;
                    location += incr;
                    if(location >= gridSize){
                        success = false;
                    }
                    if(x>0 && (location % gridLength == 0)){
                        success = false;
                    }
                } else {
                    System.out.print(" используется " + location);
                    success = false;
                }
            }
        }
        int x = 0;
        int row = 0;
        int column = 0;
        while (x < comSize){
        grid[coords[x]] = 1;
        row = (int)(coords[x]/gridLength);
        column = coords[x]%gridLength;
        temp = String.valueOf(alphabet.charAt(column));
        alphaCells.add(temp.concat(Integer.toString(row)));
        x++;
        System.out.print(" coord " + x + alphaCells.get(x-1));
        }
    
   
   return alphaCells;
    }
    
}

Не ругайтесь, я же чайник, мне можно ошибаться

Typecasting is one of the most important concepts which basically deals with the conversion of one data type to another datatype implicitly or explicitly. In this article, the concept of downcasting for objects is discussed. It’s putting the parent’s reference variable holding the child’s object to the child’s reference variable. Downcasting cannot be implicit. The syntax of downcasting is:

Type_A ref1 = new Type_B();
Type_C ref2 = (Type_D) ref1;

In this statement, two operations are performed:

1. converting an object referred by ref1 to type D
2. assigning this converted object of type D to a reference variable of type C

There are 3 rules which are checked if the downcasting will be successful or not. The rules are as discussed below:

1. Check for valid conversion

For the conversion to be valid, Type A and Type D must have a relation between them. This relation can be either type A is the parent of type D, or type D is the parent of type A or type A = type D.  If there is no such relation, then there will be a compile-time error. This rule is checked by the compiler and hence it doesn’t consider the type of object created in ref1 i.e it only considers type A and type D, not type B (which is the actual type of runtime object created). Considering this rule, let’s see some statements which satisfy the criteria.

Object ref1 = new String();
String ref2 = (String) ref1; // satisfy rule 1
ref1 is of Object type which is parent of String

Object ref1 = new String();
Integer ref2 = (Integer) ref1 ; // satisfy rule 1
ref1 is of Object type which is parent of Integer

String ref1 = new String();
String ref2 = (String) ref1 ; // satisfy rule 1
ref1 is of String type which is same

String ref1 = new String();
String ref2 = (Object) ref1 ; // satisfy rule 1
ref1 is of String type which is child of Object 

String ref1 = new String();
String ref2 = (Integer) ref1; // doesn't satisfy rule 1
ref1 is of String type which is not related to Integer 
Error: incompatible types: String cannot be converted to Integer

2. Check for a valid assignment

After downcasting, the type of the object will be typed D. We know that an object can be referred to by either the same type or its parent. This leads to the second rule that the type of ref2, type C must be a parent or the same as type D. If this rule is not satisfied then the compiler will throw an error. Considering this rule, let’s see some statements which satisfy the criteria.

Object ref1 = new String();
Object ref2 = (String) ref1 ; // satisfy rule 1 & rule 2
downcasted object of String type is referred by parent type Object

Object ref1 = new String();
Integer ref2 = (Integer) ref1; // satisfy rule 1 & rule 2
downcasted object of Integer type is referred by same type

Object ref1 = new String();
String ref2 = (Object) ref1; // satisfy rule 1 but not rule 2
downcasted object of Object type is referred by child class type String
Error: incompatible types: Object cannot be converted to String

String ref1 = new String();
Integer ref2 = (Integer) ref1; // doesn't satisfy rule 1 & rule 2
downcasted object of Integer type is referred by unrelated class type String
Error: incompatible types: String cannot be converted to Integer

3. Check the Compatibility of the runtime type of object

If we notice the above two points, they cover only the reference types and the converted type. The actual runtime type of the object we are trying to downcast is not yet taken into consideration. This runtime type will now be considered by JVM to check for validity. The child class object can be cast to the same class or parent class. This leads to the third runtime rule which is that type D must be a parent or same as of runtime type of ref1 i.e type B. If this condition fails, the JVM will throw ClassCastException at runtime. Considering this rule, let’s see some statements which satisfy the criteria.

Object ref1 = new String();
Object ref2 = (String) ref1 ; // satisfy rule 1, rul2  & rule 3
downcasted object of String type is same as runtime type String

Object ref1 = new Integer();
Object ref2 = (Number) ref1 ; // satisfy rule 1, rul2  & rule 3
downcasted object of Number type is same parent of runtime type Integer

Object ref1 = new String();
Integer ref2 = (Integer) ref1; // satisfy rule 1, rule 2 but not rule 3
downcasted object of Integer type is not same or parent of runtime type String
Exception in thread "main" java.lang.ClassCastException: class java.lang.String cannot be cast to class java.lang.Integer

Symptoms

Compilation of Java 8 code instrumented by Clover fails when a lambda expression is passed as an argument of a generic method.

Example #1 — overloaded generic methods

For the following code

public class LambdaAndGenerics {
    static interface Predicate<T> {
        boolean test(T t);
    }

    static class Fails {
        void start() {
            System.out.println(goo(e -> false)); // COMPILER ERRORS "reference to goo is ambiguous" + "cannot infer type variables"
        }
        <N> String goo(Class<N> arg) {
            return "Fails class: " + arg;
        }
        <M> String goo(Predicate<M> arg) {
            return "Fails predicate: " + arg.test(null);
        }
    }
    public static void main(String[] args) {
        new Fails().start();
    }
}

compiler fails with:

java: reference to goo is ambiguous
  both method <N>goo(java.lang.Class<N>) in LambdaAndGenerics.Fails and method <M>goo(LambdaAndGenerics.Predicate<M>) in LambdaAndGenerics.Fails match

java: incompatible types: cannot infer type-variable(s) I,T
    (argument mismatch; java.lang.Class is not a functional interface)

Example #2 — Java 8 streams

The following code:

public static List<String> testMapAndCollectBounds(List<String> input) {
    return input.stream()
            .map(e -> e.toUpperCase())
            .collect(Collectors.toList());
}

fails with a compilation error:

incompatible types: inference variable T has incompatible bounds
equality constraints: java.lang.String
lower bounds: java.lang.Object

The following code:

public static Stream<String> testMapAndFilterBounds(List<String> input) {
    return input.stream()
            .map(e -> e.toUpperCase())
            .filter(e -> !e.isEmpty());
}

fails with a compilation error:

incompatible types: java.util.stream.Stream<java.lang.Object> cannot be converted to java.util.stream.Stream<java.lang.String>

Cause

In case of example #1 it’s a bug (aka technical limitation) in Oracle’s javac compiler which fails to perform type inference for several nested generic types or methods. Roughly speaking, due to performance reasons, a compiler performs simplified method matching:

• in a first step it tries to match all methods with a given name, no matter of their signature to the lambda expression (i.e. it ignores overloading)
• in a second step it selects a method which fits the best (i.e. taking the one with the most narrow type)

In means that a compiler fails if you have two (or more) overloaded methods and one (or more) of them does have a functional interface argument, while others don’t have.

In case of example #2 this relates with a fact how type of a lambda expression or type of a method reference are being resolved by the compiler. See Java Language Specification, chapters «15.13 Method Reference Expressions» and «15.27 Lambda Expressions» for more details. Due to a fact that an original lambda is being wrapped into Clover’s helper method having a signature like this:

<I, T extends I> I lambdaInc(int index, T lambda, int stmtIndex)

this may cause problems when used with generic method having wildcards, such as:

stream()
    .map(...)       // <R> Stream<R> map(Function<? super T, ? extends R> mapper)
    .collect(...)   // <R> R collect(Supplier<R> supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R, R> combiner)

Resolution

1) Change a lambda function from an expression to a code block, e.g.:

// expression lambda
System.out.println(goo(e -> false));
// block lambda
System.out.println(goo(e -> { return false; }));

Clover uses different instrumentation for these two lambda forms, so a type inference error will not occur for a lambda block.

2) Or disable instrumentation of lambda functions declared as expressions (since Clover 3.2.2).

Use instrumentLambda = «all_but_reference», «block» or «none»

 <clover-setup instrumentLambda="block"/>

<configuration>
   <instrumentLambda>block</instrumentLambda>
</configuration>

clover {
   instrumentLambda = "block"
} 

Eclipse:

Open «Project Properties «> «Clover» page > «Instrumentation» tab. In the «Miscellaneous» box select proper value in «Instrument lambda functions» drop-down.

IntelliJ IDEA:

Open «File» > «Settings» > «Project Settings» > «Clover» page > «Compilation» tab. In the «Miscellaneous» box select proper value in «Instrument lambda functions» drop-down. 

3) Or surround a lambda by ///CLOVER:OFF and ///CLOVER:ON comments, e.g.:

... some code ...
///CLOVER:OFF
System.out.println(goo(e -> false));
///CLOVER:ON 
... some code ...

4) Or rename a method which does not have an argument of functional interface type (example #1), e.g.:

static class Works {
    void start() {
        System.out.println(goo(e -> false));
    }
    <M> String goo(Predicate<M> arg) {
        return "goo: " + arg.test(null);
    }
    <M> String goo(SomeFunctionalInterface<M> arg) {
        return "goo: " + arg.run(null);
    }
    <N> String notAGoo(Class<N> arg) { // this is not a functional interface
       return "Class: " + arg;
    }
}

5) Since Clover 4.0.5 heuristics are applied to rewrite lambda expressions in JDK Stream’s and Guava classes’ methods into a block form. More details here: Lambda rewriting heuristics. Try upgrading to Clover 4.0.5 and/or use instrumentLambda="expression" or instrumentLambda="all_but_references".

Bug tracker

CLOV-1465
—
Getting issue details…
STATUS

CLOV-1596
—
Getting issue details…
STATUS

CLOV-1762
—
Getting issue details…
STATUS