Type conversion and polymorphism in Java

We used classes to create new types (type) and use inheritance to facilitate the process of creating classes. I will delve into the type in this talk and introduce the concept of polymorphism (polymorphism).

Any of the variables and references in Java are declared in type declaration to be used. We've seen object data, class data, method parameters, method return values, and automatic variables inside methods, all of which need to declare their type. Java is a strongly typed (strongly typing) language that examines types. If we use the wrong type, it will cause an error.

For example, in the test class below, we assign a cup class object to the Aperson class reference:

Javac will return:

Found:cup
Required:human
Aperson = new Cup ();
^
1 Error

Java can type conversions of variables of a primitive type. Different basic types have different lengths and storage ranges. If we convert from a high-precision type to a low-precision type, such as converting from float to int, then we may lose information. Such conversions are called narrowing transformations (narrowing conversion). In this case, we need to display the declaration type conversions, such as:

If we convert from a low-precision type to a high-precision type, there is no concern about loss of information. Such transformations are called Loose Transformations (widening conversion). We don't need to display the required type conversions, and Java can do it automatically:

In Java, references can also be type-cast, but there are limitations.

We can convert a derived class reference to its base class reference, which is called an up conversion (upcast) or a loose conversion. The following Brokencup class inherits from the Cup class and overrides the Addwater () and Drinkwater () methods in the Cup class:

Program Run Result:

Shit, broken Cup

As you can see above, no display instructions are required, and we refer to the base class referenced by Abrokencup to it by the derived class reference Acup. Type conversions will be done automatically by Java.

We then called the Addwater () method of the Acup (which we declared to be the cup type). Although Acup is a reference to the cup type, it actually calls the Brokencup Addwater () Method! That is, even if we pass the upcast and loose the referenced type to its base class, Java can still correctly recognize the type of the object itself and invoke the correct method. Java can identify the actual type of object according to the current situation, which is called polymorphism (polymorphism). Polymorphism is an important aspect of object-oriented.

Polymorphism is a mechanism supported by Java and an important concept of object-oriented. This raises a taxonomy of questions that both subclass objects are actually "yes" to the parent class object. For example, a bird, also an animal, a car, it must be a means of transport. Java tells us that a derived class object can be used as a base class object, and Java will handle the situation correctly.

For example, the following inheritance relationship:

We can say to drink water (Drinkwater) with cups (cup). In fact, the specific meaning of the action of drinking water will change greatly in the derived class. For example, using a straw to drink water, and drinking water from a broken cup, these two action differences will be very large, although we are in the abstract "drink water." We can, of course, program each derived class separately to invoke different Drinkwater methods. However, as programmers, we can program the cups, calling the Drinkwater () method of the cup, regardless of what kind of derivative cups the cup is. Java calls the appropriate method, as we saw in the program above.

Looking at a more meaningful example, we add a drink () method to the human class, which receives a cup object and an integer as a parameter. An integer indicates the amount of water to drink:

Program Run Result:

Shit, no water inside

In the definition of drink () of the human class, we require the first parameter to be a reference to the cup type. But when actually applied (test Class), the brokencup of the Cup is derived from the class object. This is actually the hiscup upward transformation called the Cup class, passed to the drink () method. In the method, we call the Drinkwater () method. Java discovers that this object is actually a Brokencup object, so the corresponding method of Brokencup is actually called.

We can transform a base class reference downward (downcast) into a reference to a derived class, but require that the base class reference the object it is pointing to, already the derived class object to be downcast. For example, the above hiscup can be transformed upward into a cup class reference, and then down into the Brokencup class reference.

In Java, all classes actually have a common ancestor of inheritance, the object class. The object class provides methods such as ToString (). We can override these methods in our own class definitions.

We can write a program that operates on object objects, and we can pass any object to the program through Upcast.

?

Type conversion and polymorphism in Java