Java中重载与重写的区别

重载

        重载也叫做编译时多态，指一个类中可以有多个方法具有相同的名字，但这些方法的参数不同（参数的类型和个数不同）。那么代码编译的时候，就会根据参数自动选择相对应的方法编译运行。

        如果方法名和参数都是一样的，只依靠方法返回值类型的不同，或者方法返回值的不同，编译器是无法区分该调用哪个方法的，所以不能只依靠方法返回值不同来实现方法的重载。

        如果一个方法的参数不同了，也就是已经满足了重载的条件了，这个时候，方法返回值就可以不同了。

        总而言之，方法的返回值不同不能实现重载，而已经满足重载条件的方法，其返回值可以不同。

        请参考下面代码进行理解：

//重载也是一种多态
public class overload {
    public static void main(String[] args) {
        double a=10.1;
        double b=10.1;
        int c=10;
        int d=20;
        double e=5.0;
        add(a,b);
        add(c,d);
        add(a,c);
        add(c,a);
        add(a,b,e);
    }

    public static void add(double a,double b){
        double c=a+b;
        System.out.println(c);
    }

    public static void add(int a,int b){        //返回值数据类型是void
        int c=a+b;
        System.out.println(c);
    }
    public static void add(double a,int b){
        double c=a+b;
        System.out.println(c);
    }
    public static void add(int a,double b){
        double c=a+b;
        System.out.println(c);
    }

    public static void add(double a,double b,double e){
        double c=a+b+e;
        System.out.println(c);
    }
}
    //重载是指一个类中可以有多个方法具有相同的名字，但这些方法的参数不同；
    //判断重载不是看返回值数据类型，先看参数，由于下面这个add方法参数跟前面有个方法的参数一样了，
    //然后两个add()方法发返回值数据类型不同（一个是void，一个是int），编译器不知道用哪个来编译代码。所以可以说重载是根据参数的数据类型的不同来实现的，若方法返回值的数据类型不同则无法实现重载。

//    public static int add(int a,int b){         //返回值数据类型是int
//        int c=a+b;
//        System.out.println(c);
//        return c;
//    }

重写

         重写也叫运行时多态，重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！

        重写的好处在于子类可以根据需要，定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法。

（1）在类的继承中，总会使用到重写。

public class Demo {
    public static void main(String [] args){
        Student student = new Student();
        student.display();
        student.work();
    }
}
class Person {
    String name;
    public void work(){
        System.out.println("尽心尽力地工作");
    }
    public void display(){
        System.out.println("这是一个Person类");
    }
}
class Student extends Person {
    public void display(){
        System.out.println("这是一个Student类");    //重写
    }
}

        当子类需要父类的功能，而功能主体子类有自己持有内容时，可以重写父类中的方法，这样既沿袭了父类的功能，又定义了子类特有的内容。

        如同上面子类Student继承了父类，所有继承了父类的方法display()，但子类持有自己的内容，所以在从父类继承下来的diaplay()方法中重写了方法中的内容（"这是一个Student类"）。

（2）不仅在普通的类的继承中会使用到重写，在抽象类的继承中也会用到。

        如果一个类继承了抽象类，那么它必须实现抽象类的所有抽象方法，而实现其抽象方法就需要使用到重写方法。

public abstract class Teacher {
    public abstract void work();
}
class MathTeacher extends Teacher{
    public void work(){                    //重写work()方法
        System.out.println("我正在上数学课");
    }
}
class ChineseTeacher extends Teacher{
    public void work(){                    //重写work()方法
        System.out.println("我正在上语文课");
    }
}


public class Demo {
        public static void main(String[] args) {
            MathTeacher mathteacher = new MathTeacher();
            mathteacher.work();
            ChineseTeacher chineseteacher = new ChineseTeacher();
            chineseteacher.work();
        }
}

 （3）重写在接口中也会频繁使用。

eg.

class 类 implements 接口{

        重写接口中的方法

}

        在类实现接口后，该类就会将接口中的抽象方法继承过来，此时该类需要重写该抽象方法，完成具体的逻辑。当一个类需要某些功能时，就实现具有这些功能的接口，在接口中定义的功能，就叫功能的声明；在类中重写的方法，实现了功能，就叫功能的具体实现。

public class Demo {
    public static void main(String[] args) {
        Phone phone = new Phone();
        phone.Func();
        Computer computer = new Computer();
        computer.Func();
    }

}

public interface Usb {          //接口定义时需要使用interf关键字
    void Func();
}
class Phone implements Usb{         //类实现接口使用implements
    @Override
    public void Func() {            //类实现接口后，该类就会将接口中的抽象方法继承过来，此时该类需要<重写>该抽象方法
        System.out.println("通过usb接口，给手机充电");
    }
}
class Computer implements Usb{      //类实现接口使用implements
    @Override
    public void Func() {            //类实现接口后，该类就会将接口中的抽象方法继承过来，此时该类需要重写该抽象方法
        System.out.println("通过usb接口，进行数据转移");
    }
}

以上列举了几个关于重写的运用，重写在其他方面也有许多运用，如在异常中的运用等。