Why do we need type casting in programming?

Answer 1

Becuase, sometimes data is in a form that is unrecognizable to the program. Example:

int a = 2;

int b = 3;

double c = a / b;

We cast c as a double. if it was not, then the data would not have a decimal value.

Answer 2

The most common use of type casting is to convert one numeric type into another.

// Let's say we have this square root function:

double sqrt(double s) {

double xn = s / 2.0;

double lastX = 0.0;

while(xn != lastX) {

lastX = xn;

xn = (xn + s/xn) / 2.0;

}

return xn;

}

// Now let's also say that we have an array with some data already in it:

int[] array = {/*some data*/};

// If we want to access the information in that array, we need an integer-typed value.

// So what happens if we want to use the square root of a number as an index?

// This line will not work, since sqrt(4) will return the floating point value 2.0

print array[sqrt(4)];

// So we try it again, but cast that 2.0 as an integer to get 2

print array[(int) sqrt(4)];

Type casting is also popular in object-oriented programming languages when polymorphism and inheritance come into play.

Answer 3

You sometimes need to explicitly cast objects in Java when dealing with polymorphism. The reason is best explained in the example below. We'll be looking at an example where you press a button and make it so that the button is set to a disabled status.

// Create the button object

JButton reloadButton = new JButton("Disable me");

// Add a new ActionListener, which will define the code to run when the button is pressed

reloadButton.addActionListener(new ActionListener() {

public final void actionPerformed(ActionEvent ev) {

// Here is where we need to perform an action on the button.

// Unfortunately, this class cannot directly reference the button.

// (Actually, we can modify some things so that we can, but let's pretend

// it's impossible for the sake of a simple example.)

// Fortunately, there's a nice little function in ActionEvent called getSource

// which will return the "object on which the Event initially occurred."

// Unfortunately (again), it returns the Object on which the event occurred.

// That is to say, we don't get a reference to a JButton. So we need to

// clear that up to Java before we can call the setEnabled function on it.

// So let's cast our Object to get a JButton we can use...

final JButton source = (JButton) ev.getSource();

// ...and modify.

source.setEnabled(false);

// For those of you who like concise code, we could have written it in one line:

((JButton) ev.getSource()).setEnabled(false);

// And thus we need to explicitly cast an object in Java.

}

});

Answer 4

Because, without Casting we cannot utilize the full potential of the Java Programming Language