java重载（overload）和重写（override）

1.重载overload

　　表示一个类中可以有多个名称相同的方法，但这些方法的参数列表不同。（类型不同，顺序不同）

class A{
    public void fun(int a,float b){
        
    }
    public void fun(float a, int b) {
        // TODO Auto-generated method stub
    }
    public void fun(int a, int b, int c) {

    }
}

　　不可以通过用不同的返回值来实现重载

class A{
    public void fun(int a,float b){
        
    }
    public int fun(int a,float b){
        return 1;
    }
}

2.重写override

class A{
    public A tt(A a){
        return a;
    }
}

// 1.重写的方法返回值类型可以是被重写方法返回值相同的类型（或者子类型），
public class B extends A{
    @Override
    public B tt(A a) {
        // TODO Auto-generated method stub
        return new B();
    }
}    

public class B extends A{
    @Override
    public A tt(A a) {
        // TODO Auto-generated method stub
        return new A();
    }
}    

public class B extends A{
    // 出错，参数类型必须与被重写方法原来的类型一致，不然就不是重写了，而算是新增了一个方法，需要去掉注解override
    @Override
    public A tt(B a) {
        // TODO Auto-generated method stub
        return new A();
    }
}    

重写override需要满足：

　　参数类型必须与被重写方法原来的类型一致（不能是其子类），否则算是新增的一个方法

　　覆盖方法的返回值必须和被覆盖方法的返回值类型一致，或者是其子类。

　　被覆盖的方法不能是private权限，否则也算是新增了一个方法，不能算作覆盖。

　　覆盖的方法抛出的异常必须和被覆盖方法抛出异常的类型一致，或者是其子类。

static静态方法不能被重写,子类若定义一个“同方法名，同参数”的方法，只是相当于新增了一个方法

class A{
    public static void ss(){
        System.out.println("A static fun");
        
    }
}

public class B extends A{
    public static void ss(){
        System.out.println("B static fun");
    }
        public static void main(String[] args) {

        A a = new B();
        a.ss();
        System.out.println();
        B b =new B();
        b.ss();
    }
}    

输出为：

A static fun

B static fun

　　假设静态方法能被重写，根据上转型对象的规则，a调用ss()时应该是B重写的ss()方法，输出应该是“B static fun”

final方法 不能被重写，并且子类“同名、同参数”的方法也不能定义

　　子类可以定义“同名，不同参数的方法”，相当于新增的方法

class A{
    public final void ff(int a){
        System.out.println("A final fun");
    }
}
public class B extends A{
//    public final void ff(){  //可以被定义，相当于新增的方法
//        System.out.println("B final fun");
//    }
//    public static void ff(){ //可以被定义，相当于新增的方法
//        System.out.println("B staticfun");
//    }
//    public final void ff(int a,int b){ //可以被定义，相当于新增的方法
//        System.out.println("B final fun");
//    }
    
    public final void ff(int a){ //不行，方法名，参数名相同，不能被重写。连被定义作为一个新增的方法也不行
        System.out.println("B final fun");
    }
    
    
    public static void main(String[] args) {

        A a = new B();
        a.ff();
        System.out.println();
        B b =new B();
        b.ff();
    }
}

　　子类同名的方法，参数为父类final方法的子类型，也相当于新增了一个方法

class A{
    public final void ff(A a){
        System.out.println("A final fun");
    }
}
public class B extends A{
    
    public final void ff(B b){ // 可以，相当于一个新增的方法，b是A的子类型，但是不是同参数类型。
        System.out.println("B final fun");
    }
    
    
    public static void main(String[] args) {

        A a = new B();
        a.ff();
        System.out.println();
        B b =new B();
        b.ff();
    }
}

注意：final 与 static区别

当父类有一个static方法时，在子类中定义一个同名，同参数的方法时，相当于新增了一个方法

当父类友谊个final方法时，子类中不能定义一个同名，同参数的方法（当参数为父类同名方法参数的子类型的时候，不能当做同参数）