2022-07-25 Gu Yujia's study notes

polymorphic

Polymorphic core code ： A parent type reference points to a child type object

 No matter the conditions of upward or downward transformation ： Only the existence of inheritance can transform 
 The first form of polymorphism ：（ Upward transformation ）
   Parent class   Parent object  = new  Subclass ();
 subtypes  —>  Parent type 
 Upward transformation can automatically transform 

1.  Automatic transformation , Implicit conversion , Upward transformation is The parent class reference points to the child class instance , It can also be said that ： Subclass objects can be assigned Parent class

2. It's safe to move up , Because subclasses override parent methods , The parent class reference points to that subclass , Just call this subclass Write a method

3. Upward transformation , A parent class reference can only call subclass override methods , You cannot call subclass specific methods , If you want to call , It will Must be Move down

4. Static methods of a parent class are not allowed to be overridden by subclasses

 The second form of polymorphism ：（ Move down ）
   The premise of downward transformation , We need to make an upward transformation first , Can be converted to subclass type through strong conversion .
 Parent type  —>  subtypes 
 Downward transformation requires mandatory type converter ​​​​​​​

1. Forced transformation Explicit conversion , Downward transformation refers to the reference of subclasses, which refers to the reference of parent classes , It can also be said that , The parent class is forced to be subclassed

You can call Subclass specific methods

2. It is easy to be abnormal during transformation ClassCastExcepiton Happen .

3. Prevent this kind of abnormality , Need to use java Provided instanceof （ Object comparison operators ）, Make classes for reference variables

Type verification

• Object name instanceof data type
• If the object belongs to this type , Just go back to true
• If the object does not belong to this type , Just go back to ​​​​​​​​​​​​​​
• After the downward transformation You can call subclass specific methods , But first, we need to transform upwards

  public static void main(String[] args) { 2 // The requirement is to call the crayon specific coloring method 
  Pen p=new WaxCrayon(); // Upward transformation   Son to father   Automatically 
  if(p instanceof WaxCrayon){ // Prevent type conversion exceptions 
  WaxCrayon w=(WaxCrayon)p; // Move down   Parent rotor   mandatory 
  w.color(); } }

When to use downward transformation

In polymorphism , When a parent type references a child type object , If you need to access subclass specific properties or methods , We need to move down , Otherwise the compilation will not pass .

 The formation of polymorphism has 3 Conditions 
  1、 Have inherited 
  2、 There's rewriting 
  3、 There is a parent object pointing to a subclass reference 

instanceof keyword ： Determine whether an object is an instance of a class , The return value is boolean type 

 Method rewrite ：
  The return value of the overridden method can be a subclass of the return value of the overridden method .void

Anonymous object  

 grammar ：new  Class name ();
 function ： It has the same function as normal named objects .
       It still has the call attribute , Function of method .
 Use scenarios ： Most of them are used to transmit parameters , Actual parameters , In most cases, it is used with constructors 
 benefits ： Saving resource .