how to achieve polymorphism in java

() {System.out.println ("show Fu");}} Class Zi extends Fu {public void Show () {System.out.println ("show Zi");} public void Method () {System.out.println ("method Zi");}} Class DuoTaiDemo3 {public static void main (string[] args) {//Test fu F = new Zi (); F.show (); F.method ();//Because there is no method () in the parent class. So the error. Error description: Cannot find Symbol}} So how should we solve this problem? Downward transformation. An introduction to the downward transformation wil

(string[] args) {//TODO auto-generated method stub//d_1 B = New D_1 ();//defines the instantiation object of a subclass//c_1 a = b;//declares a parent class, an upward-transition relationship occurs, the subclass assigns a value to the parent class//a.fun1 ();//This method is overridden by the quilt class, although a is the parent class, but the Fun1 () method of the subclass is called c_1 C = New D_1 ();//declares a parent class that has undergone an upward transformation, the subclass is assi

PrivateString name;3 Private intAge ;4 PublicString GetName () {5 returnname;6 }7 Public intAge () {8 returnAge ;9 }Ten One } A Public classChildextendsfather{ - PublicString GetName () { - return Super. GetName ();//access to parent private data in this way the } -}(2) about static member variablesChild classes have these member variables in the parent class, regardless of whether the member variables in the parent class are static o

1. The Java reference variable has two types: one is the compile-time type, one is the runtime type, and the compile-time type is determined by the type used when declaring the variable, and the type of the runtime is determined by the object that is actually assigned to the variable. If the compile-time type and run-time type are inconsistent, the so-called polymorphism occurs;2. The reference variable can

classes like perform () or new ones derived from dance, you will add a lot of work, and by comparison you will know that the first code will prevail, which is the advantage of polymorphism, which improves the organization and readability of the code while ensuring extensibility.So how does the JVM point to play () in the Latin class? To solve this problem, Java uses the concept of late binding. When sendin

As one of the three major features of Java, Polymorphism is an important feature that many people have not figured out, and today I come from the perspective I understand.First of all, from his literal meaning to understand, polymorphic, from its literal understanding is a variety of forms, multiple manifestations. According to these, I most can think of the example is the graph, the graph is a very big cla

demonstrated by the example. This method is very convenient, because you are getting clasDoes not need to generate objects of the class type. However, if you already haveYou can call getclass () to obtain the class reference. This is the root class objec.Provided. It returns a class reference to indicate the actual type of the object. Class provides some interestingThe following example shows the Methods: Rtti allows you to discover type information by referencing anonymous base classes. Beginn

, the subclass of the overriding shot method is also stored there, when you rewrite the parent class method, the subclass will point to the subclass implementation of the shot method, that is, according to the type of the current object to execute the corresponding method.In fact, the gun class here can be replaced by abstract classes or interfaces, assuming we use interfaces. When a subclass implements the shot method of the gun, we use the interface's Reference object to access the implementat

class on the basis of inheriting the parent method, and in the concrete execution is the method of executing the subclass;⑵ subclasses can define their own properties, methods, which is a manifestation of code extensibility;All classes in ⑶java, if no defined definition inherits from, the default is inherited from Object;⑷ (special note) in Java, each class can inherit only one class ———— Java's single-inh

There should be no stranger to Polymorphism. It is an old friend who develops object-oriented systems. But old friends may also be "upset", huh, huh. Sometimes you don't pay attention to it. For example, the following example (thank Hayden ). You can choose not to look at the following answer, but run it in your mind to see if your thoughts are consistent with the actual results. Public class Polymorphism {

one Java polymorphic Polymorphism is the ability of the same behavior to have many different manifestations or forms.Polymorphism is the embodiment of multiple forms of objects. For example, we say, "PetObject ". It has many different expressions or implementations, such as kittens, puppies, lizards, and so on. So I went to the pet store and said, "Please give me a pet."The waiter gave me a kitten, a puppy

the method defined in the type of the reference variable. This dynamic binding enables polymorphism. Only the runtime is able to determine which method is called specifically. So an instance covered by a method is also known as run-time polymorphism .Note that member variables are not polymorphic , and the value of the member variable depends on the type of the defined variable . public class Father { p

currently popping up under Word, Windows Help and Support appears under Windows. The same event occurs on different objects and produces different results.--------------------------The last example I think is inappropriate, should say: When you take a bus, you lean on a person's shoulder, if the other side is a man, he may give you a punch, if the other is a beautiful woman, she may give you a palm. Different objects (men or beauties), to the same message (by), make a different response (punch

Java Foundation 12-polymorphism is a feature of a member1, member variable.Both compilation and run refer to the left side of the equals sign.Overrides occur only on functions, and variables do not matter.Fu f = new Zi ();System.out.println (f.num);//is the parent class, the answer is 32, member function (non-static).Compile to see left, run to see right.Because the member function has an override attribute

the subclass A1,a2 method. In fact, this is the manifestation of polymorphism, here to refer to late binding thisConcept, late binding is done by the compiler, and at compile time, the compiler does not need to obtain any special information to make the correct call.In simple terms, a reference to a parent type can point to an object of a subtype. There is also a way to invoke a parent class with a reference to a parent class that does not have a met

Today, we are talking about the most important thing in Java object-oriented, polymorphic. Polymorphism allows us to maximize the reusability of our programs, which is why we learn polymorphism."Polymorphic" (polymorphic) is also called "dynamic binding", also called "Late binding" (late binding).Dynamic binding refers to "the actual type of the referenced object

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

method and the final method because cannot be inherited, so at compile time can determine their values, they belong to the early bound. Specifically, the method and member variables of the private declaration cannot be inherited by the quilt class, and all private methods are implicitly specified as final (we can also know that the method is declared as one of the final types to prevent the method from being overwritten. The second is to effectively close the dynamic bindings in

First-degree Niang a multi-state concept:polymorphic = = Late binding .Do not interpret function overloading as polymorphic.Because polymorphism is a run-time behavior, not a compile-time behavior.Polymorphic: A reference to a parent type can point to an object of a subtype.For example, Parent p = new Child ();　　　　When calling a method using polymorphic mode, first check if there is a method in the parent class, and if not, compile the error;If so, th

On the Java Foundation of the article, I think it can also be written in my other blog, is definitely original, and now share to everyone out. --------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------------------- ---------Abstract class, interface, polymorphism