Java 重写和重载

方法重写

返回值特性：子类重写父类方法，名字、参数一样，返回值必须是父类返回值的子类，编译会报错。

异常特性: 子类抛出的异常不能超出父类抛出的异常

访问级别: 子类方法的访问级别不能低于父类的访问级别

class Father{
    private String name;
    protected Father(String name){
        this.name = name;
    }

    protected Object setName(String name)throws Exception{
        this.name = name;
        return name
    }
}

class Son extends Father{

    private Son(String name) {
        super(name);
    }
    /*
	 * 子类的访问级别是   public > protected
     * 子类的返回值类型是 String < Object
     * 子类抛出的异常    IOException < Exception
     */
    public String setName(String name)throws IOException{
        return name;
    }
}

方法重载

相同的方法名称，不同的方法特征签名，返回值不属于重载的特征签名

方法特征签名: 参数类型、参数顺序、参数个数。

//静态分派
class Person{
    protected String name = "Person";
}
class Human extends Person{
    protected  String name = "Human";
}
class Man extends Person{
    protected  String name = "Man";
}
class Wuman extends Person{
    protected  String name = "Wuman";
}
public class MethodOverLoad {
    public static void sayHello(Person person){
        System.out.println("Hello World : " + person.name);
    }
    public static void sayHello(Human person){
        System.out.println("Hello World : " + person.name);
    }
    public static void sayHello(Man person){
        System.out.println("Hello World : " + person.name);
    }
    public static void sayHello(Wuman person){
        System.out.println("Hello World : " + person.name);
    }

    public static void main(String[] args) {
        Person human = new Human();
        Person man = new Man();
        Person wuman = new Wuman();
		//这个属于静态分派，在编译时已经决定要调用的是哪一个方法
        sayHello(human);
        sayHello(man);
        sayHello(wuman);
    }
}

//动态分派
/**
  * 抽象动物类
  */
abstract class Animal{
    protected String name = "";
    protected abstract void sayHello
} 
/**
  * 子类Dog
  */
class Dog extends Animal{
   public Dog(){
       this.name = "Dog";
   }
    
   @Override
   protected void sayHello(){
       System.out.println(this.name);
   }
}
/**
  * 子类cat
  */
class Cat extends Animal{
 	
    public Cat(){
        this.name = "Cat";
    }
    
    @Override  
    protected void sayHello(){
        System.out.println(this.name);
    }
}


public class DynamicDispath{
    public static void main(String[] args){
        Animal dog = new Dog();
        Animal cat = new Cat();
        //动态分派，因为在编译期，是无法可dog的类型 只有在运行期间才能知道
        dog.sayHello();
        cat.sayHello();
    }
}

例子只是说明方法的参数类型.当方法的参数只有一个时，方法的调用顺序

即存在一个调用顺序char -> int -> long ->double ->
当没有基本类型就是继续找基本类型的包装类型
如果没有包装类方法，则调用包装类实现的接口的方法。