How to cast super class object to sub class object in Kotlin?

Here I am trying to converting superclass object to subclass. I am getting the runtime error as "class can not be cast".

Eg :

class Animal {}
class Cat : Animal() {}

class abc {
fun abcd(): Animal {
    return Animal()
}

fun getData() {
    val cat: Cat = abcd() as Cat     //Giving me runtime error.
}
}

You can't cast a base class 'instance' to a descendant class, because a base class does not necessarily implement the behaviors of its descendants neither knows anything about them.

In your specific example the method abcd() returns an instance of the base class Animal, and therefore such can't be cast to Cat, since Animal may not have any of the behaviors defined in Cat.

An example, imagine you had also a Dog class, and both Cat and Dog implement different methods such as dog.fetch() and cat.jump(). Such behaviors don't exist in the base class Animal, and therefore it can't be explicitly cast to a specific animal.

The opposite is valid, so casting Cat to Animal, because Cat inherits the behaviors of its base class Animal.

Instead, what you can do is to instantiate a Cat in abcd(), and still return Animal:

fun abcd(): Animal {
    return Cat()
}

This is valid, and the casting will work. But, you must pay attention to avoid potential ClassCastException's at runtime if mixing up derived classes, for example if instantiating a Dog while the return type is Animal and try to use it as Cat.

Small remark: I'm assuming the reason Animal isn't open in your example is just a copy/paste mistake, as it clearly needs such keyword to allow inheritance.

Maybe what you are trying to do is something like creating a type and based on what sub-type then do something, like this:

sealed class Animal

data class Cat(val...) : Animal()
data class Dog(val...) : Animal()

class YourMapper {
    fun animal(condition: Type): Animal {
        return when(condition) {
            ... -> Dog(...)
            ... -> Cat(...)
        }
    }

    fun getData(condition: Type): Animal {
        return animal(condition)
    }

And then the usage is

val data = YourMapper().getData(condition)
when(data) {
  is Dog -> {/*do something with your dog*/}
  is Cat -> {/*do something with your cat*/} 
}

I know this is an old question, but it's the first Google hit for the search "Kotlin how to cast superclass to subclass", so for prosperity:

How to cast to subcalss in Kotlin
use the "as" keyword as in the original question:

if(animal is Cat) {
    Cat cat = animal as Cat
}

The original question
Short answer, you can't cast a superclass object to a subclass object. Casting only changes the type of the reference to the object, the object itself remains unchanged.

The Animal class in the question should almost certainly be marked as abstract. That way there's no possibility to accidentally instantiate non-specific animals, which is what happens in the question and causes the exception.

An Animal reference variable can absolutely be cast to a Cat, provided the object it references is a Cat. But in the question a non-specific Animal is instantiated, and then later attempted to cast to a Cat, but as it is not referencing a Cat object, this understandably throws an exception.

So unlike, say, casting an Int to a Double where the cast seemingly changes the type of the object, casting object references doesn't actually "change" the object, only how finely-grained your reference to it is.
Casting cannot turn a Dog into a Cat, it can only change you from examining an animal as a generic Animal, viewing properties commont to ALL animals, to examining it as a Cat or a Dog and additionally having access to the properties only Cats or Dogs have.