Course Java Core - Lecture: Type casting. Widening and narrowing conversions

"Hi, Amigo! The topic of today's lesson is widening and narrowing type conversions. You learned about widening and narrowing primitive types a long time ago. On Level 10. Today we're going to talk about how it works for reference types, i.e. instances of classes."

In fact, it's all quite simple. Imagine a class's inheritance chain: the class, its parent, the parent of the parent, etc., all the way back to the Object class. Because a class contains all member methods of the class it inherits, an instance of the class can be saved in a variable whose type is that of any of its parents.

Here's an example:

Code Description

class Animal
{
public void doAnimalActions();
}class Cat extends Animal
{
public void doCatActions();
}class Tiger extends Cat
{
public void doTigerActions();
}

Here we have three class declarations: Animal, Cat, and Tiger. Cat inherits Animal. And Tiger inherits Cat.

public static void main(String[] args)
{
Tiger tiger = new Tiger();
Cat cat = new Tiger();
Animal animal = new Tiger();
Object obj = new Tiger();
}

A Tiger object can always be assigned to a variable whose type is that of one of its ancestors. For the Tiger class, these are Cat, Animal, and Object.

Now let's take a look at widening and narrowing conversions.

If an assignment operation causes us to move up the inheritance chain (toward the Object class), then we're dealing with a widening conversion (also known as upcasting). If we move down the chain toward the object's type, then it's a narrowing conversion (also known as downcasting).

Moving up the inheritance chain is called widening, because it leads to a more general type. However, in doing so we lose the ability to invoke the methods added to the class through inheritance.

Code Description

public static void main(String[] args)
{
Object obj = new Tiger();
Animal animal = (Animal) obj;
Cat cat = (Cat) obj;
Tiger tiger = (Tiger) animal;
Tiger tiger2 = (Tiger) cat;
}

When narrowing the type, you need to use a type conversion operator, i.e. we perform an explicit conversion.

This causes the Java machine to check whether the object really inherits the type we want to convert it to.

This small innovation produced a manifold reduction in the number of type casting errors, and significantly increased the stability of Java programs.

Code Description

public static void main(String[] args)
{
Object obj = new Tiger();
if (obj instanceof Cat)
{
Cat cat = (Cat) obj;
cat.doCatActions();
}}

Better yet, use an instanceof check

public static void main(String[] args)
{
Animal animal = new Tiger();
doAllAction(animal);

Animal animal2 = new Cat();
doAllAction(animal2);

Animal animal3 = new Animal();
doAllAction(animal3);
}

public static void doAllAction(Animal animal)
{
if (animal instanceof Tiger)
{
Tiger tiger = (Tiger) animal;
tiger.doTigerActions();
}

if (animal instanceof Cat)
{
Cat cat = (Cat) animal;
cat.doCatActions();
}

animal.doAnimalActions();
}

And here's why. Take a look at the example on the left.

We (our code) don't always know what type of object we are working with. It could be an object of the same type as the variable (Animal), or any descendant type (Cat, Tiger).

Consider the doAllAction method. It works correctly, regardless of the type of object passed in.

In other words, it works correctly for all three types: Animal, Cat, and Tiger.

public static void main(String[] args)
{
Cat cat = new Tiger();
Animal animal = cat;
Object obj = cat;
}

Here we have three assignment operations. All of them are examples of widening conversions.

The type cast operator is not needed here, because no check is necessary. An object reference can always be stored in a variable whose type is one of its ancestors.

"Oh, the second to last example made everything clear: why the check is needed, and why type casting is needed."

"I hope so. I want to draw your attention to this fact:"

None of this causes an object to change in any way! The only thing that changes is the number of methods available to be called on a particular reference variable.

For example, a Cat variable lets you call the doAnimalActions and doCatActions methods. It doesn't know anything about the doTigerActions method, even if it points to a Tiger object.

"Yep, I get it. It was easier than I thought it would be."

Comments (49)

TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION

Andrew Evans Level 17, San Jose, Canada

28 February 2022

Think about what set of methods can be called by the reference variable and it makes sense

ImDevin Level 15, Old Town, United States

5 June 2021

lots of comments here about widening & narrowing. I think of it as a giant whirlpool in the ocean. It narrows as you get sucked into it & you can take methods with you. As you come up (if you could :), it widens, but you can't bring any method up with you. Goofy imagery, I know, but it helps me to remember. Happy coding! :)

Karas Level 20, Tampa, United States

14 March 2021

I am just also adding here something that I do not remember being covered and then suddenly you are supposed to know how to use. For Downcasting mainly: Cat tigger= new Tiger(); In this case if you call the methods inside Tiger as an example: tigger.roar(); it will give an error, unless of course there is a roar method in the Cat class, but cats do not roar in this example. So to solve it you can use: ((Tiger) tigger).roar(); Practically simple, but so far I had to google that or seen it in some solutions. Hope it helps.

Oliver Heintz Level 18, Mustang, United States

5 December 2020

So, if we had: Cat cat = new Tiger(); ...is cat a cat, or is cat a tiger? Can the cat that I created access Tiger methods, or is the new Tiger() object that I created immediately widened to Cat and now can't access Tiger methods? I guess this is where I'm confused. Because why not just Cat cat = new Cat() if all we wanted was a Cat to start with?

Lawson Level 29, Lagos, Nigeria

27 August 2020

i dont really understand this

Agent Smith Level 38

26 August 2020

Here is how to remember this notion easily and never be confused about it again: 1. Object is the WIDEST class in Java. Because it has the biggest iheritance tree under it. 2. So when you go down that tree, you are NARROWING, because less and less ancestors will be there. +Remember that when we are widening with primitives, we don't needs explicit casting. Same here. That's all you practically need. If you want a better understanding why is it so, consider the following: when you have a parent reference variable pointing to any of its children, you can ALWAYS be sure that the child will have all its parents fields (via inheritance). So it is safe to have a more general variable pointing to a more specific child. But the opposite is not true and thus we need a check (cast). Easy! :)

Ryan Level 16, Ashburn, United States

19 July 2020

I feel like this lesson contradicts the previous lesson (Level 10 Lecture 6) on this on what is widening vs what is narrowing: https://codegym.cc/quests/lectures/questsyntax.level10.lecture06 . The examples in the previous lesson (10.6) show going from Object to the String, Integer, etc. is a widening conversion while this lesson says "Moving up the inheritance chain is called widening, because it leads to a more general type." I think both lessons are consistent on when a cast operator is called (going from a parent to a child class) but they seem to contradict which direction is widening and which is narrowing.

Thang Za Thang Level 18, Melbourne, Australia

11 July 2020

Too many conflicting on narrowing and widening: Am I right here? Here's a visual in my head: Object 0 --- > If you reach here, it's widening where your access to methods is lost. ..... Animal animal ..... Cat cat ...... Tiger tiger ------> If you reach here, you are narrowing, which means you have more access to methods?

HaeWon Chung Level 17, Boston, United States

17 May 2020

Ok, so my understanding is that


Animal animal = (Animal) obj;

Is narrowing. Then, is this widening?


Object obj = new Tiger();

If the above is widening, does that mean that obj lost all methods that are specific to Tiger and Cat classes? Can I say that if the variable type is not exactly same as assigned object, it is either widening or narrowing. Is that correct?

TARAS Level 22, Lviv, Украина

11 January 2020

i'm totaly lost here.