Typecasting transforms one data type into another, and object typecasting includes upcasting and downcasting. The object can also be typecast in Java, just as datatypes. Additionally, there are two sorts of objects: parent and child objects. Parent to Child and Child to Parent, or Upcasting and Downcasting, are the two types of typecasting that can occur for an object.
The object can also be typecast in Java, just as datatypes. There are two sorts of objects: parent and child objects. Parent to Child and Child to Parent, or Upcasting and Downcasting, are the two types of typecasting that can occur for an object.
To check whether variables are handled appropriately by a function, typecasting is employed.
We simultaneously typecast a child object to a parent object and a parent object to a child object in upcasting and downcasting. Upcasting can be done expressly or implicitly, but downcasting is not feasible implicitly.
Let’s explore Upcasting of the object casting in depth in this article!
Upcasting
A type of object typecasting called upcasting involves typecasting a child object to a parent class object. We may access the variables and methods of the parent class in the child class by utilizing upcasting.
Here, we only access a portion of the procedure and variables. Only a few specific child class variables and methods are accessed. Broadening and generalization are other names for upcasting. The Syntax of Upcasting is as follows:
<div class="wp-block-codemirror-blocks-code-block code-block"> <pre>ParentObject po = new ChildObject();</pre> </div>
Internal upcasting will take place, and as a result, the object can only access certain members (overridden methods, etc.) of the parent and child classes.
<div class="wp-block-codemirror-blocks-code-block code-block"> <pre>// The subsequent variable is not readily accessible po.id = 1;</pre> </div>
Illustrating the concept of Upcasting in Java
Allow for a parent class. A parent may have several children. Now, take one of the youngsters as an example. The parent’s attributes are passed on to the child. The parent and child, therefore, have an “is-a” relationship. As a result, the parent may be implicitly upcasted to the child. A parent, however, may or may not inherit a child’s possessions. But downcasting, or forcing a parent onto a child, is possible.
After explicitly specifying it, the compiler checks in the background to see if this form of casting is possible. The compiler throws a ClassCastException if it is not feasible. To further explain the idea of Java’s upcasting, let’s examine the following code:
<div class="wp-block-codemirror-blocks-code-block code-block">
<pre>// Upcasting.java
class ParentObject{
void showInfo() {
System.out.println(" parent's class method");
}
}
class ChildObject extends ParentObject {
void showInfo() {
System.out.println(" child class's method ");
}
}
class CodeUpcasting{
public static void main(String args[]) {
ParentObject firstObj = (ParentObject) new ChildObject();
ParentObject secondObj = (ParentObject) new ChildObject();
firstObj.showInfo();
secondObj.showInfo();
}
} </pre>
</div>
Another sort of object typecasting is upcasting. A parent class reference object is given to the child class during upcasting. Although it is impossible to give a parent class reference object to a child class in Java, if downcasting is used, there won’t be any compile-time errors. The “ClassCastException” is thrown when we attempt to run it.
To better understand the use of upcasting in Java, we will employ an example of downcasting to drive the point home. The question is, why does the compiler permit downcasting if it is not possible in Java? In some Java contexts, downcasting is an option. The parent class, in this case, refers to the subclass object. Here is a downcasting example that explains both the legitimate and the illegitimate scenarios:
<div class="wp-block-codemirror-blocks-code-block code-block">
<pre>// Downcasting.java
// this class belongs to a Parent
class ParentObject {
String name;
// A method that prints the data of the parent class
void displayMessage()
{
System.out.println("Parent method is called");
}
}
// this class belongs to a Child
class ChildObject extends ParentObject {
int age;
// Performing overriding
@Override
void displayMessage()
{
System.out.println("Child method is called");
}
}
public class Downcasting{
public static void main(String[] args)
{
ParentObject po = new ChildObject();
po.name = "Tyson";
// Performing Downcasting Implicitly
//ChildObject c = new ParentObject(); // it gives compile-time error
// Performing Downcasting Explicitly
ChildObject co = (ChildObject)p;
co.age = 18;
System.out.println(co.name);
System.out.println(co.age);
co.displayMessage ();
}
} </pre>
</div>
Why is upcasting necessary in Java?
Upcasting is not frequently used in Java. When writing code that solely affects the parent class, we use it. Downcasting is used when writing code to access the child class’s actions.
What is outstanding about Upcasting
The following are key identities of upcasting in Java, leading to a clearer understanding of the variations between upcasting and downcasting. A parent object receives a typecast of a child object. On the other hand, the parent class object’s reference is supplied to the child class when handling downcasting.
Upcasting can be done expressly or implicitly. However, it is not feasible to downcast implicitly.
We have access to the parent class’s variables and methods in the child class when upcasting in Java. On the contrary, you can access the parent and child classes’ methods and variables when performing downcasting. In addition, we can only access a few specific child class methods in Java’s upcasting. But by using downcasting, it is possible to access all of the variables and methods of both classes.
The syntax for Java’s upcasting is as follows:
<div class="wp-block-codemirror-blocks-code-block code-block"> <pre>ParentObject po = new ParentObject()</pre> </div>
Now, contrast this with Java’s downcasting, which is represented using the following code snippet.
<div class="wp-block-codemirror-blocks-code-block code-block"> <pre>ParentObject po = new ChildObject() ChildObject co = (ChildObject)po;</pre> </div>
Example: Demonstrating the idea of typecasting in General
<div class="wp-block-codemirror-blocks-code-block code-block">
<pre>// This is Java's program illustrating the variation of Upcasting and Downcasting
// this class belongs to a parent
class ParentObject {
String name;
// this method is responsible for printing the parent class's signature
void displayMethod()
{
System.out.println(" Parent class's Method");
}
}
// Child class
class ChildObject extends ParentObject {
int id;
// this method overrides its parent method & subsequently prints the child class's signature
@Override void displayMethod()
{
System.out.println("Method from Child");
}
}
// this class demonstrates the differences arising between upcasting and downcasting
public class CUS {
// The program's driver's code
public static void main(String[] args)
{
// Upcasting
ParentObject po = new ChildObject();
po.name = "CodeUnderScored";
//the parent class name being printed
System.out.println(po.name);
//Since the parent class function is overridden, we will use this.
po.displayMethod();
// making attempts to implicitly downcast
// ChildObject co = new ParentObject(); - > compile time error
// Downcasting Explicitly
ChildObject co = (ChildObject)po;
co.id = 1;
System.out.println(co.name);
System.out.println(co.id);
co.displayMethod();
}
}
</pre>
</div>
Conclusion
One of the most crucial ideas is typecasting, which essentially deals with the implicit or explicit conversion of one data type to another. We have explosively covered the idea of upcasting typecasting for objects in this article.
The objects can also be typecasted, just like the data types. There are only two types of objects in objects: parent objects and child objects. Typecasting of objects, then, fundamentally refers to the conversion of one kind of object, such as a child or parent, to another.
Casting a given child object to a parent object is known as upcasting. Implicit upcasting is a possibility. Upcasting allows us the freedom to access the parent class members, but it is impossible to use this feature to access all the child class members. We can access a subset of the child class’s members rather than all. We can, for example, access the overridden methods.
