java中重写与重载的区别

文章参考来源：https://www.cnblogs.com/upcwanghaibo/p/6527354.html

 

重载：同一个类中不同方法具有相同的名字，但是参数不一样，即参数的名称和参数的类型不一样。同类不同参

重写：子父类的，即子类与父类具有相同的方法名字还有参数参数相同和相同的返回类型。即同名同参同类型

子类不能重写父类中的final方法，必须重写父类的abstract（抽象）方法。

重载（overloading）：

方法重载是让类已统一的方式去处理不同类型数据的一种手段，多个同名函数存在，但具有不同的参数个数/类型。是一个类中多态的表现

java的方法重载：就是在同一类中创建多个方法，让他们具有相同的名字，但具有不同的参数个数和类型。调用方法时根据传入的不同参数个数和参数类型来决定使用哪种方法。多态的表现。

重载的时候返回值得类型可以相同也可以不同。

public class Dog {
    //构造函数
    public Dog(){
        
        this.bark();
    }
    //重载方法
    void bark() {
        System.out.println("no barking!");
        this.bark("female", 3.4);
    }
   void bark(String n,double s) {
       System.out.println();
   }
   void bark(double s,String n) {
       System.out.println();
   }
   public static void main(String[] args) {
    
       Dog dog = new Dog();
}
}

重写（overriding）：

父与子类之间的多态性，对父类函数进行重新定义，如果在子类中定义的某方法与其父类具有相同的参数和方法名，即重写，也称方法覆盖。

如果子类中的方法与父类中的方法名一致且参数一致，则新方法覆盖父类的方法。如需引用父类的方法，则使用super方法。

  public class Base
    {
        void test(int i)
        {
            System.out.print(i);
        }
        void test(byte b)
        {
            System.out.print(b);
        }
    }
    public class TestOverriding extends Base
    {
        void test(int i)
        {
            i++;
            System.out.println(i);
        }
          public static void main(String[]agrs)
        {
            Base b=new TestOverriding();
            b.test(0)
            b.test((byte)0)
        }
    }

Base作为父类，TestOverriding作为子类，上面的例子中，TestOverriding子类中的方法覆盖父类的方法，在main方法中b指向实际类型TestOverriding，所以b.test(0)实际指向子类中的方法，但是子类中没有定义test(byte b)方法，所以b.test((byte)0)指向父类的方法，如果把父类的(byte b)注释掉，则通过第二步隐含类型转化为int,最终调用的是子类的test(int i)。

public class Father{

  public void speak(){

       System.out.println("你好")；

}

}

public class Son extends Father{

public void speak(){

system.out.println("你不好")；

}

}

重写方法只能重写具有继承关系，只能重写父类非私有的方法。

当父类中的方法被private时，子类不能重写父类的方法，此时，相当于子类再定义一个方法。

当父类被final时，不管方法前是什么修饰词都不能被重写。

Father类speak()方法被默认修饰时，只能在同一包中，被其子类被重写，如果不在同一包则不能重写。

Father类speak()方法被protoeted时，不仅在同一包中，被其子类被重写，还可以不同包的子类重写。

重写方法的规则：

1、参数的类型与数量必须相同，否则就是重载了；

2、返回的类型必须一直与被重写的方法的返回类型相同，否则不能称其为重写而是重载。

3、访问修饰符的限制一定要大于被重写方法的访问修饰符（public>protected>default>private）

4、重写方法一定不能抛出新的检查异常或者比被重写方法申明更加宽泛的检查型异常。例如：

父类的一个方法申明了一个检查异常IOException，在重写这个方法是就不能抛出Exception,只能抛出IOException的子类异常，可以抛出非检查异常。

重载的规则：

1、参数必须不同

2、返回的类型可以不同

3、修饰符可以不同

4、异常可以不同

面试题：重载（Overload）和重写（Override）的区别。重载的方法能否根据返回类型进行区分？ 
答：方法的重载和重写都是实现多态的方式，区别在于前者实现的是编译时的多态性，而后者实现的是运行时的多态性。重载发生在一个类中，同名的方法如果有不同的参数列表（参数类型不同、参数个数不同或者二者都不同）则视为重载；重写发生在子类与父类之间，重写要求子类被重写方法与父类被重写方法有相同的参数列表，有兼容的返回类型，比父类被重写方法更好访问，不能比父类被重写方法声明更多的异常（里氏代换原则）。重载对返回类型没有特殊的要求，不能根据返回类型进行区分。

重写与重载：

class Parent {

    public Parent make(int i) {
        System.out.println("Parent int: "+i);
        return null;
    }
}

class Child extends Parent{

    @Override
    public Child make(int i) {
        System.out.println("Child int: "+i);
        return null;
    }

   public Child make(Integer i) {      
        System.out.println("Child Integer: "+i);
        return null;
    }
}

public class OverrideTest { 
    public static void main(String []args){
        Parent p = new Parent();
        Child c = new Child();
        p.make(1);                  //Parent int: 1
        p.make(new Integer(1));     //Parent int: 1
        c.make(1);                  //Child int: 1
        c.make(new Integer(1));     //Child int: 1
    }
}