The difference between overload and override

heavy load overload

Purpose of overloading ： Save naming resources in classes and improve code readability .

Overloading occurs in a class ,
1、 Same method name
2、 The parameters of the method are different ( Number of parameters or parameter type )
3、 The return value type of the method does not affect overloading
（ When two methods have the same name , The parameters are the same , But when the return value is different , Does not constitute a heavy load ）

class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int ret = add(a, b);
        System.out.println("ret = " + ret);
    }
    public static int add(int x, int y) {
        return x + y;
    }
    public static double add(int x, int y) {
        return x + y;
    }
}
// Here are two add  Same parameters for , The return value type is different , Constitute heavy load 

  rewrite override

Rewriting means The subclass implements the method with the same name as the parent class , Method parameters and return value types are exactly the same ;

Rewriting occurs between a subclass and a superclass , That is to say, rewriting is not in the same class ;

When a subclass inherits a parent class , The method of the subclass is the same as that of the parent （ Access qualifier , return type , Method name , parameter list ）, Different methods , The method of this subclass overrides the method of the parent class, which is called rewriting ;

class Animal {
    public void eat(String food) { 
 		...
    }
}

class Bird extends Animal {
    @Override
    public void eat(String food) { 
		...
    }
}
// here  Bird Medium  eat  Yes  Animal  Medium eat  Rewrite 
// There are the same methods in the inheritance of parent and child classes , The only difference is the method body ,
// Generally, the method of the parent class cannot meet the needs of the child class, so it is rewritten .

Be careful ：

1.  Rewriting and overloading are completely different , Don't mix up. 
2.  Common methods can override ,static  Modified static methods cannot override 
3.  The access permission of the method overriding the subclass cannot be lower than that of the parent class 

The differences between overloading and rewriting are summarized in the following table ：

  Back to our systemverilog , I mentioned about method addition before virtual The question of modification , In short, it's in Methods in the parent class are rewrite , Add do not add virtual The difference of decoration has been explained above ;

And for phase for , Every component Of phase All right. uvm_component Of phase Rewriting of , And in uvm_component It's all added in virtual modification , So at least stay Method This level sv There is no overload in, only rewriting (override)！！ Errors will be reported as follows ：

class A;

　　virtual function int dis(string str="A");

　　　　$display("this is %s",str);

　　　　dis=1;

　　endfunction

endclass

class B extends A;

　　function void dis(); //  Only the function name is the same , Different parameters 

　　　　$display("this is B");

　　endfunction

endclass

Many say , It's like uvm_primer It's written in yes new To overload , This point will be discussed later ！！