Course New Java Syntax - Lecture: Reference type conversions

"And now, a short lesson from Diego. Brief and to the point. About reference type conversions."

"Let's start with Object variables. You can assign any reference type to such a variable (widening conversion). However, to make the assignment in the other direction (narrowing conversion), you must explicitly indicate a cast operation:"

Code	Description
`String s = "mom"; Object o = s; // o stores a String`	A typical widening reference conversion
`Object o = "mom"; // o stores a String String s2 = (String) o;`	A typical narrowing reference conversion
`Integer i = 123; // o stores an Integer Object o = i;`	Widening conversion.
`Object o = 123; // o stores an Integer String s2 = (String) o;`	Runtime error! You cannot cast an Integer reference to a String reference.
`Object o = 123; // o stores an Integer Float s2 = (Float) o;`	Runtime error! You cannot cast an Integer reference to a Float reference.
`Object o = 123f; // o stores a Float Float s2 = (Float) o;`	Conversion to the same type. A narrowing reference conversion.

"A widening or narrowing reference conversion doesn't change the object in any way. The narrowing (or widening) part specifically refers to the fact that the assignment operation includes (does not include) type-checking of the variable and its new value."

"This is the rare example where everything is clear."

"To avoid the errors in these examples, we have a way to find out what type is referenced by the Object variable:"

Code

int i = 5;
float f = 444.23f;
String s = "17";
Object o = f;                       // o stores a Float

if (o instanceof  Integer)
{
    Integer i2 = (Integer) o;
}
else if (o instanceof  Float)
{
    Float f2 = (Float) o;            // This if block will be executed
}
else if (o instanceof  String)
{
    String s2 = (String) o;
}

"You should perform this check before every widening conversion unless you are 100% sure of the object's type."

"Got it."

public static void main(String[] args) { Dog dog = new Dog(); Lab lab = (Lab) dog; Lab lab2 = new Lab(); Dog dog2 = lab2; } static class Dog { } static class Lab extends Dog { }

Comments (31)

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

Hoist Level 22, San Diego, United States

4 April 2023

See Ivan summary below --

MrPreston Level 11, Edinburgh, United Kingdom

6 July 2021

Think of reference types (Class objects) as a set of buckets. Object class is the biggest bucket, so ANY other reference type (class) can be placed in the Object bucket no problem (no casting). But if you wanted to take a big bucket (like object) and put it into a smaller bucket you need to state you are okay with losing some data/precision and so you must cast. Strings, Longs, Integer, Doubles, Cats, Dogs, etc...can all be assigned to their own object reference. But the other way round requires you to cast your types/references. Now imagine you have a Dog class. and You also have a Labrador class that extends the Dog class. This means the Dog bucket is bigger than the Labrador bucket. So you can put a Labrador instance into a dog reference without casting. But if you want to assign a dog to the lab class you must cast.

Sinisa Level 11, Banja Luka, Bosnia and Herzegovina

26 March 2021

"You should perform this check before every widening conversion unless you are 100% sure of the object's type." This check should be performed before every narrowing conversion, that is what you've wanted to say, right 😏

Syed Umar Level 1, Gothenburg , Sweden

13 March 2021

This is the first time,I regret visiting the comments section🤣 You guys confused me more now what is right and what is wrong!

Jurij Thmsn Level 29, Flensburg, Germany

1 February 2021

I don't get why in the article it says "Let's start with Object variables. You can assign any reference type to such a variable (narrowing conversion). However, to make the assignment in the other direction (widening conversion), you must explicitly indicate a cast operation:" - I understand: narrowing conversion - ok. widening conversion - use cast operator. But in the following examples it is the exact opposite: when there is a narrowing conversion - cast is used. I am really confused.

Dmitri Level 22, Seversk, Russia

16 November 2020

how come that this is narrowing (from this article) - Object o = "mom"; // o stores a String String s2 = (String) o; but this is widening (also from this article) - Object o = 123f; // o stores a Float Float s2 = (Float) o; ??

Chandan Thapa Level 22, Dubai, United Arab Emirates

3 November 2020

well understood!

Ryan Level 16, Ashburn, United States

19 July 2020

To help everyone not go through what I did, the terms widening and narrowing are wrong here and you learn the correct terms in Lesson 14 Lecture 3: "Moving up the inheritance chain is called widening, because it leads to a more general type. " When a cast operator is needed remains consistent though, you need a cast operator when you go from the base class (or parent class) to the inheriting class (or child class). You can verify this in the Oracle documentation: https://docs.oracle.com/javase/specs/jls/se8/html/jls-5.html#jls-5.1.5

Nikitata Level 22, Ba Sing Se, United States

13 July 2020

Has anybody discovered the copy text hack?? Recently figured it out, but it is good practice to complete these tasks. Highlight the text, then double click. Click on the "Copy" option and Ctrl-V the code into the "Your Code:"... Useful when you're at rock bottom with these copy-paste tasks

Vesa Level 41, Kaliningrad, Russia

25 November 2019

A widening reference conversion exists from any reference type S to any reference type T, provided S is a subtype (§4.10) of T.