Java区分---OverLoad重载与Override重写

一. 函数的重载

       在同一个类中，允许存在一个以上的同名函数，参数个数或者参数类型不同的同名函数就叫做重载。重载的特点：与返回值无关，只看参数列表。
       当定义的功能相同，但参与运算的未知内容不同，那么，就定义一个相同的函数名称以表示其功能，方便阅读，而通过参数列表的不同来区分多个同名函数。

示例：

public static void main(String[] args){    add(4,5);    add(4,5,6); //通过参数个数来区分调用哪个函数}public static int add(int a, int b){    return a+b;}public static int add(int a, int b, int c){    return a+b+c;}

示例： 构造函数的重载：一个类能产生多个对象，而这些对象又可以去调用不同的初始化对象。

class Person{    private String name;    public Person(){}    public Person(String name)    {        this.name = name;    }    public static void main(String[] args)    {        new Person();        new Person("name"); //可以调用不同的初始化对象    }}

< 练 习 >给定一个函数，比较下面有没有和它重载

void show(int a, char b, double c){}//原函数//[a]void show(int x, char y, double z){} //没有，因为和原函数一模一样//[b]int show(int a, double c, char b){}//重载了，因为参数类型不同，注意：重载和返回值类型无关，参数也是有顺序的//[c]void show(int a, double c, char b){} //重载了，参数是有顺序的//[d]boolean show(int c, char b){} //重载了，因为参数个数不同//[e]void show(double c){} //重载了，因为参数个数不同//[f]double show(int x, char y, double z){} //没有，参数一样，返回值虽然不同，但是不是重载，并且这个函数不允许和给定的函数

---

二. 函数的重写 （覆盖）

1. 类
      当子类出现和父类一模一样的函数时，如同父类的函数被覆盖一样，这是函数的另一个特性：重写。（父类方法还在内存中，只是没有运行）
       当子类继承父类，沿袭了父类的功能到子类中，但是子类虽具备该功能，但是功能的内容却和父类不一致，这时没有必要定义新的功能，而是使用覆盖特性保留父类的功能定义并重写功能内容。

( 1 ) 子类覆盖父类：

        1. 必须保证子类权限大于等父类权限，才可以覆盖，否则编译失败。【注】默认权限介于私有private和公有public之间。
        2. 父类方法私有时，不是重写。因为子类都不知道父类有此方法，子类定义了同名函数只是定义了子类自己的方法。

示例：

class Parent{    private void show(){}}class Son extends Person{    public void show(){} //此处子类并没有重写父类的方法}

       3.子类要覆盖父类，必须与父类的方法一模一样，包括返回值类型。

( 2 ) 静态方法只能覆盖静态方法：因为静态是优先存在于对象的存在

( 3 ) 父类中的构造函数不能被重写：

        1. 在子类对象进行初始化时，父类的构造函数也会运行，那是因为子类的构造函数默认第一行有一条隐式的语句super()；它会访问父类中空参数的构造函数，而且子类中所有的构造函数默认第一行都是super()。（隐式super()是Java虚拟机加上的）

        2. 为什么子类一定要访问父类中的构造函数？
      因为父类中的数据，子类可以直接获取，所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的，所以子类对象在初始化时要先访问一下父类中的构造函数，如果要访问父类中的指定的构造函数，可以通过手动定义super(参数)的方式来指定。

实例：手动定义super()

class Parents{    private String name;    public Parents(){}    public Parents(String name)    {        this.name = name;    }}class Son extends Parents{    public Son()    {        super("name"); //指定调用父类带参数构造方法    }}

       3. this()和super()在同个子类构造函数中不能并存，所以都需要放第一行，也就是要先做初始化动作。子类的构造函数第一行也可以手动指定this()语句来访问本类中的构造函数，但是子类中至少有一个构造函数会访问父类中的构造函数。

实例：子类指定this()，但至少一个构造函数调用super()

class Son extends Parents{    public Son()    {        this("name"); //指定调用子类带参数构造方法    }    public Son(String name)    {        super(name); //指定调用父类带参数构造方法    }}

( 4 ) 被final修饰的方法不能被重写

---

2. 抽象类
       抽象类中的抽象方法要被使用，必须有子类重写其所有的抽象方法后，建立子类对象调用。如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。

示例：

abstract class Student{    abstract void study();    abstract void say();}abstract class BestStudent() extends Student //BestStudent类仍然是抽象类{    void study(){}    abstract void say();}

3. 接口
       1. 接口需要被子类实现，子类对接口中的抽象方法全部覆盖后，子类才可以实例化，否则子类是一个抽象类。
       2. 接口中的成员都有固定的修饰符：
                常量：public static final
                方法：public abstract
        在子类重写父类方法时，其权限必须大于父类权限，所以子类方法必须用public修饰。

示例：

interface Parents{    int NUM = 3; //常量的修饰为public static final    void show(); //方法的修饰为public abstract}class Son implements Parents{    public void show(){};}

4. 多态
多态的前提：必须是类与类之间有关系，要么继承，要么实现。通常还有一个前提：存在覆盖。

示例：

abstract class Student{    public abstract void study();    public void sleep()    {        System.out.println("student is sleeping");    }}class BestStudent extends Student{    public void study()    {        System.out.println("bestStudent is studying");    }    public void sleep()    {        System.out.println("bestStudent is sleeping");    }}class DoStudent //工具类{    public void dosome(Student stu)    {        stu.study();        stu.sleep();    }}class Demo{    public static void main(String[] args)    {        DoStudent d = new DoStudent();        d.dosome(new BestStudent());    }}