Java中方法的重载与重写

方法的重载和重写在面试中经常会出现，所以我的学习笔记希望可以帮到你，有错误处烦请指正。

一、二者的定义和代码的一些细节

1.1方法的重载Overload

同一个类中可以存在同名的方法。那么如何区分他们呢，如我们所知方法的括号中是方法的参数（空括号时为空参方法）。由于形参列表的不同，当调用方法时括号内的参数列表不同，调用相对应的方法。这些不同形参列表的方法，就构成了方法的重载。

1.1.1重载的好处

方便方法有不同参数需求时的使用

1.1.2代码例子

public class test {
    public static void main(String[] args) {
        testOverride test = new testOverload();
        //测试空参方法
        test.testFuction();
        //测试含参方法
        test.testFuction(12);
    }
}

class testOverload{
    //类的属性
    private int id;
    //类的getter and setter
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    //空参方法
    public void testFuction() {
        System.out.println("这是空参方法");
    }
    //单参数方法
    public void testFuction(int id) {
        setId(id);
        System.out.println("这是含参数的方法，传入参数为id: " + getId());
    }
}

运行结果

当然，类的构造器也可以重载，那么代码就可以写成下面这样

public class test {
    public static void main(String[] args) {
        testOverride test = new testOverload();
        testOverride test1 = new testOverload(123);
    }
}

class testOverload{
    //类的属性
    private int id;

    //构造器
    //1空参构造器
    public testOverload() {
        System.out.println("创建对象成功");
    }
    //2含参构造器
    public testOverload(int id) {
        this.id = id;
        System.out.println("这是含参数的构造器，传入参数为id: " + id);
    }
}

运行结果

注意：构造器里可以方法私有的属性的奥

1.2方法的重写Override

方法的重写，又叫方法的覆盖，通常见于java的继承中，当子类的方法需要和从父类中继承来的方法区分开的时候，就要重写该方法。

1.2.1方法重写的好处

实现子类不同于父类的方法需求

1.2.2代码例子

如果子类没有重写空参方法，后面那个含参的方法还能调用吗？

Suer！当然！

二、从编译和运行的角度看

重载，从编译器角度看，重载的方法为不同的多个方法。它们的调用地址在编译时就已经绑定了。而重写在运行时才能确定具体的调用的方法。

所以说：

重载 早绑定 静态绑定

重写 晚绑定 动态绑定

2.1重写代码在运行时才能确定调用的证明

public class test {
    public static void main(String[] args) {
        int randInt = new Random().nextInt(3);
        func(getInstance(randInt));
    }
    //调用传入动物地方法叫声
    public static void func(Animal animal) {
        animal.shout();
    }
    //根据参数创建随机对象并返回
    public static Animal getInstance(int key) {
        switch (key) {
            case 0 : return new Dog();
            case 1 : return new Cat();
            case 2 : return new Sheep();
            default: return null;
        }
    }
}

class Animal {
    public void shout() {
        System.out.println("动物：叫声");
    }
}
class Dog extends Animal {
    public void shout() {
        System.out.println("汪！汪！汪！");
    }
}
class Cat extends Animal {
    public void shout() {
        System.out.println("喵！喵！喵！");
    }
}
class Sheep extends Animal {
    public void shout() {
        System.out.println("咩！咩!咩!");
    }
}

这样一来，是不是不知道会调用哪个子类的方法了？这就是重写动态绑定的体现