解释之前遗留的方法覆盖问题

1 私有方法无法覆盖。

2 方法覆盖只是针对于“实例方法”，静态方法覆盖没有意义(这是因为方法覆盖通常和多态联合起来)。

    

    总结两句话：

        私有不能覆盖。

        静态不谈覆盖。

 

3 在方法覆盖中，关于方法的返回值类型。

    什么条件满足之后，会构成方法的覆盖呢？

        1 发生在具有继承关系的两个类之间。

        2 父类中的方法和子类重写之后的方法：

            具有相同的方法名、相同的形式参数列表、相同的返回值类型。

    

    学写了多态机制后:

        “相同的返回值类型”可以修改一下吗？

            对于返回值类型是基本数据类型来说，必须一致。

            对于返回值类型是应用数据类型来说，重写之后返回值类型可以变小（但意义不大，实际开发中，没人这样写）。

 

// 静态方法没有覆盖意义案例：

/*
    1 方法覆盖需要和多态机制联合起来使用才有意义
        Animal a = new Animal();
        a.move();
        
        要的是什么效果？
            编译的时候move()方法是Animal的。
            运行的时候自动调用到子类重写move()方法上。
            
        假设没有多态机制，只有方法覆盖机制，你觉得有意义吗？
            没有多态机制的话，方法覆盖可有可无。
            没有多态机制，方法覆盖也可以没有，如果父类的方法无法满足子类的业务需求的时候，子类完全可以定义一个全新的方法。
            
        方法覆盖和多态不能分开。
            
    2 静态方法存在方法覆盖吗？
        多态自然就和对象有关系了。
        而静态方法的执行不需要对象。
        所以，一般情况下，我们会说静态方法“不存在”方法覆盖。
        不探讨静态方法的覆盖。
        
*/
public class OverrideTest05{
    public static void main(String[] args){
        // 静态方法可以使用“应用.”来调用吗？可以
        // 虽然使用“引用.”来调用，但是和对象无关。
        Animal a = new Animal();
        // 静态方法和对象无关。
        // 虽然使用“引用.”来调用。但是实际运行的时候还是：Animal.doSome();
        a.doSome();
        Cat.doSome();
    }
}

class Animal{
    public static void doSome(){
        System.out.println("Animal的duSome()方法执行了！");
    }
}

class Cat extends Animal{
    // 尝试在子类当中对父类的静态方法进行重写
    public static void doSome(){
        System.out.println("Cat的duSome()方法执行了！");
    }
}

// 私有方法无法被覆盖的案例：

// 经过测试，你记住就行
// 私有方法不能被覆盖
public class OverrideTest06{
    
    // 私有方法
    private void doSome(){
        System.out.println("OverrideTest06's private method doSome execute!");
    }
    
    public static void main(String[] args){
        OverrideTest06 test06 = new T();
        test06.doSome();//OverrideTest06's private method doSome execute!
    }
}

/*
class Mymain{
    public static void main(){
        OverrideTest06 test06 = new T();
        test06.doSome();//错误: doSome() 在 OverrideTest06 中是 private 访问控制
    }
}
*/

class T extends OverrideTest06{
    // 尝试重写父类中的doSome()方法
    // 访问权限不能更低，可以更高。
    public void doSome(){
        System.out.println("T's public method doSome execute!");
    }
}

学写了多态机制后:

        “相同的返回值类型”可以修改一下吗？案例：

public class OverrideTest07{
    public static void main(String[] args){
        // 一般重写的时候都是复制黏贴，不要动。也不要改。
    }
}

class Animal{
    /*
    public double sum(int a,int b){
        return a + b;
    }
    */
    
    /*
    public long sum(int a,int b){
        return a + b;
    }
    */
}

class Cat extends Animal{
    // 重写
    // 错误: Cat中的sum(int,int)无法覆盖Animal中的sum(int,int)
    // 错误: Cat中的sum(int,int)无法覆盖Animal中的sum(int,int)
    /*
    public int sum(int a,int b){
        return a + b;
    }
    */
    
    /*
    public double sum(int a,int b){
        return a + b;
    }
    */
}

class MyClass1{
    public Animal getAnimal(){
        return null;
    }
}

class MyClass2 extends MyClass1{
    // 尝试重写父类的方法
    /*
    public Animal getAnimal(){
        return null;
    }
    */
    
    // 重写的稍后返回值类型由Animal变成了Cat，变小了。（可以，Java中允许）
    /*
    public Cat getAnimal(){
        return null;
    }
    */
    
    // 重写的时候返回值类型由Animal变成了Object。变大了。(不行，java中不允许)
    // 返回类型Object与Animal不兼容
    public Object getAnimal(){
        return null;
    }
}