Java面向对象基础（5-多态）

多态

*多态分为两种。一种是之前已经讲过的方法重载，另一种就是现在要讲的方法覆写。

方法重载：是同一类中，相同方法名，但不同参数列表，这样的叫做函数重载。
方法覆写：子类继承父类，子类若有一个方法的方法签名和返回值和父类完全一致，这就称为方法覆写。

举个方法重载的例子：

class Student{
    private String name;
    private int age;
    
    public void Set(){
        this.name="Hong";
    }
    
    public void Set(int age){
        this.age=age;
    }
    
    public void Set(String name,int age){
        this.name=name;
        this.age=age;
    }
}

然后再举个方法覆写的例子：

class Person{
    public void Hello(){
        System.out.println("Hello,this is a Person!");
    }
}
class Student extends Person{
    @Override     //可以让编译器帮忙检查是否进行了正确的覆写。
    public void Hello(){
        System.out.println("Hi,this is a Studnet!");
    }
}

然后方法覆写有什么用呢？
我们看下面这段代码：

public class Main {
    public static void main(String[] args) {
        Person Hong = new Student();
        Hong.Hello();
    }
}
class Person{
    public void Hello(){
        System.out.println("Hello,this is a Person!");
    }
}
class Student extends Person{
    @Override
    public void Hello(){
        System.out.println("Hi,this is a Studnet!");
    }
}

输出：
Hi,this is a Studnet!

Java的实例方法是基于运行时的实际类型的动态调用，而非变量的声明类型。
这个非常重要特性在面向对象编程中称为多态。

然后我们通过一个例子来看一下多态的作用

public class Main {
    public static void main(String[] args) {
        Person []person = new Person[]{new Hong(),new Ming(),new Jun()};
        HelloEveryone(person);
    }
    public static void HelloEveryone(Person []person){
        for(Person p:person)
                p.Hello();
    }
}
class Person{
    public void Hello(){
        System.out.println("Hello,this is a Person!");
    }
}

class Hong extends Person{
    @Override
    public void Hello(){
        System.out.println("Hi,this is Hong!");
    }
}
class Ming extends Person{
    @Override
    public void Hello(){
        System.out.println("Hi,this is Ming!");
    }
}
class Jun extends Person{
    @Override
    public void Hello(){
        System.out.println("Hi,this is Jun!");
    }
}

输出：
Hi,this is Hong!
Hi,this is Ming!
Hi,this is Jun!

可以看出，多态的作用是，允许添加更多类型的子类实现功能的扩展，而不需要修改基于父类的代码。

• 调用super

使用super调用父类的被覆写的方法。

class Person{
    public void Hello(){
        System.out.println("Hello,this is a Person!");
    }
}

class Hong extends Person{
    @Override
    public void Hello(){
        super.Hello();  
        System.out.println("Hi,this is Hong!");
    }
}

• final
  继承允许子类覆写父类的方法，但是如果不想父类的方法被子类覆写，那么就可以在父类的方法前加上修饰词final，前面有final的方法不允许被override。
  若覆写一个final方法，会编译错误，“Hong中的Hello()无法覆盖Person中的Hello()，被覆盖的方法为final”

class Person{
    final public void Hello(){
        System.out.println("Hello,this is a Person!");
    }
}

若不想让一个类被其他类继承，可以在这个类之前加上final，即最终类的意思。
若继承一个final类，会编译错误，“无法从最终Person进行继承”

final class Person{
    public void Hello(){
        System.out.println("Hello,this is a Person!");
    }
}