java基础中重载和重写的区别

一、使用“方法的重载机制”和不使用“方法的重载机制”的比较

1.不使用“方法的重载机制”，分析程序存在的缺点？

package 重载;

public class test01 {

    public static void main(String[] args) {
        //调用方法
        int sumInt = sumInt(1, 2);
        System.out.println(sumInt);		//3

        double sumDouble = sumDouble(1.0, 2.0);
        System.out.println(sumDouble);	//3.0

        long sumLong = sumLong(1L, 2L);
        System.out.println(sumLong);	//3
    }

    //定义一个方法，可以计算两个int类型数据的和
    public static int sumInt(int a,int b){
        return a + b;
    }

    //定义一个方法，可以计算两个double类型数据的和
    public static double sumDouble(double a,double b){
        return a + b;
    }

    //定义一个方法，可以计算两个long类型数据的和
    public static long sumLong(long a,long b){
        return a + b;
    }

}

• 以上程序的案例可以看出，sumInt、sumDouble、sumLong方法虽然功能不同，但是功能是相似的，都是求和。在程序当中功能相似的方法，分别起了三个不同的名字，这对于程序员来说，调用方法的时候不方便，程序员需要记忆更多的方法，才能完成调用。

2.使用“方法的重载机制”，分析程序的优点

package 重载;

public class test02 {
    public static void main(String[] args) {
        System.out.println(sum(1,2));	//3
        System.out.println(sum(1.0,2.0));	//3.0
        System.out.println(sum(1L,2L));		//3
    }

    public static int sum(int a,int b){
        return a + b;
    }

    public static double sum(double a,double b){
        return a + b;
    }

    public static long sum(long a,long b){
        return a + b;
    }
}

• 以上程序可以看出，调用方法的时候就像在使用一个方法一样
• 参数的类型不同，对应调用的方法就不同，此时区分方法不再依靠方法名了，依靠的是参数的数据类型
• 程序员调用方法的时候，比较方便。虽然调用的是不同的方法，但是就感觉在使用一个方法一样，不需要记忆个更多的方法名。还有就是代码更加的美观了

二、方法的重载

1.方法的重载又被称为：overload

2.什么时候考虑使用方法重载？

• 功能相似的时候，尽可能让方法名相同。但是，功能不同的时候，尽可能让这两个方法的名字不同（比如做加法和减法）

3.什么条件满足之后构成了方法重载？

• 在同一个类当中（都在OverloadTest01这个类中）
• 方法名相同（都是m1或者都是m2或者都是m3）
• 参数列表不同：
  • 数量不同（方法里有参数和没有参数）
  • 顺序不同（方法里参数数据类型的顺序）
  • 类型不同（方法里参数的数据类型）

package 重载;

public class OverloadTest01 {
    public static void main(String[] args) {
        m1();
        m1(10);

        m2(1,2.0);
        m2(2.0,1);

        m3(10);
        m3(3.0);
    }
    //以下两个方法构成重载
    public static void m1(){}
    public static void m1(int a){}

    //以下两个方法构成重载
    public static void m2(int a,double b){}
    public static void m2(double a,int b){}

    //以下两个方法构成重载
    public static void m3(int x){}
    public static void m3(double x){}

}

4.方法重载和什么有关系，和什么没有关系？

• 方法重载和方法名+参数列表有关系
• 方法重载和返回值类型无关

public static void x(){}
public static int x(){
    return 1;
}

• 方法重载和修饰符列表无关

void y(){}

public static void y(){}

三、方法的重写

package 重写;

public class Test {
    public static void main(String[] args) {
        //创建子类对象
        Cat cat = new Cat();
        //调用方法
        cat.move();		//打印出   猫在走猫步
    }
}

//父类：动物
class Animal{
    //成员方法
    public void move(){
        System.out.println("动物在移动");
    }
}
//子类：猫
class Cat extends Animal{
    //Cat的move方法应该输出：猫在走猫步
    //Animal中的move方法已经无法满足Cat了
    //所以要在Cat类中对Animal类中的move方法进行重新定义（方法的覆盖，方法的重写，Overwrite，Override）
    public void move(){
        System.out.println("猫在走猫步");
    }
}

1.什么时候方法要进行重写？

• 如果父类中的方法已经无法满足当前子类的业务需求，需要将父类中的方法进行重新写一遍，也就是重写

2.子类如果重写父类中的方法之后，子类对象一定调用的是重写之后的方法

• 上面程序只会打印出“猫在走猫步”
• 如果子类对象的重写方法给注释掉，则会打印出“动物在移动”

3.发生方法覆盖的条件：

• 第一：发生在具有继承关系的两个类之间
• 第二：必须具有相同的方法名（move），相同的返回值类型（void），相同的参数列表（重写方法中没有参数，与父类成员方法中相同）
• 第三：重写的方法不能比被重写的方法拥有更低的访问权限（比如子类重写的方法中如果将public删除掉，程序就会报错。如果将父类成员方法的public删除，则不会报错）
• 第四：重写的方法不能比被重写的方法抛出更宽泛的异常。（如果在子类重写的方法中抛出异常throws Exception，程序就会报错，因为父类中的成员方法没有抛异常）
• 第五：私有的方法不能被覆盖（比如父类中有自己独有的方法，该方法不能被子类继承）
• 第六：构造方法无法被覆盖，因为构造方法无法被继承
• 第七：静态的方法不存在覆盖（比如父类中的static修饰的方法）
• 第八：覆盖指的是成员方法，和成员变量无关

4.继承最重要的作用：继承复用，方法可以重写，用来重新定义子类的行为

如果对你有帮助，不如点个赞，也算是支持一下0.0
若有不正之处，请多多谅解并欢迎批评指正，不甚感激