Method overloading and rewriting

Method overloading

What is method overloading ？

     Method overloading refers to , You can define multiple methods with the same name , But the parameters are different .
     Invocation time , The corresponding method will be automatically matched according to the different incoming parameters .
    == Overloaded method , It's actually a completely different approach , It's just that the method name is the same ==

The conditions that make up method overloading

1. Different meanings ： parameter types 、 Number of formal parameters 、 The order of formal parameters is different
2. Only the return value is different , Does not constitute an overload of a method
Such as ：int a(String str){} And void a(String str){} Does not constitute a method overload
3. Only the names of formal parameters are different , Does not constitute an overload of a method
Such as ： int a(String str){} And int a(String a){} Does not constitute a method overload

Code

summary

 1.  Method overloading ： In the same class , Same method name , Multiple methods with different formal parameter lists ,        Call it method overloading 
 2.  Dependency of method overloading ：  Method overloads are related to method names and formal parameters , And modifier and return    Value type independent 
 3.  Be careful ： Unlike the formal parameter list, it refers to ？
 (1) The number is different. ：
 add();  add(int a,int b);   add(int a,int b,int c);
 (2) Different order ：
 add(int a,double b);   add(double a,int b);
 (3) Different types ：
 add(int a);    add(double a);
4.  Make a simple overload judgment 
 (1)add(int a)  and  add (int b) ----> It doesn't constitute , It is equivalent to repeated definition of method , meaningless .
 (2)public static int add(int a)  and  public static void add(int b)----> It doesn't constitute 

expand

Method rewriting

The occurrence condition of rewriting

 Occurs in subclasses and superclasses , When a child class inherits a parent class , And are not satisfied with the method provided by its parent class , Rewritable 

Rewriting has strict format requirements

 The method name of the subclass override must be the same as that of the parent , And with the parameter list in the parent class method （ Number 、 type 、 The order ） bring into correspondence with ！

public class Person {
    // Parent class -- human beings 
    public void eat(){
    
        System.out.println(" I like to eat pig elbows ...");
    }

    public void sleep(){
    
        System.out.println(" I like sleeping ");
    }
}

public class Student extends Person{
    // Subclass -- Student 

    public void study(){
    
        System.out.println(" I love learning ...");
    }
    @Override // Overload comment 
    public void eat(){
    
        System.out.println(" I love string ...");
    }

}

public class Student extends Person{
    // Subclass -- Student 

    public void study(){
    
        System.out.println(" I love learning ...");
    }
    @Override // Overload comment 
    public void eat(){
    
        System.out.println(" I love string ...");
    }

}

public static void main(String[] args) {
    
        Student st = new Student();
        st.eat();
        st.sleep();
    }
 Running results ：
 I love string ...
 I like sleeping  

Memory analysis

The difference between overloading and rewriting

 heavy load ： In the same class , Same method name , Multiple methods with different formal parameter lists , Constitute heavy load 
 rewrite ： In different classes , When the subclass inherits the parent method and is not satisfied , Rewrite its method