Java中的重载&重写

About Me

欢迎各位读者访问，大家一起学习。

优秀是一种习惯♡♡♡

做更好的自己！

本人见识有限，写到博客难免有错误或疏忽的地方，还望各位大佬多多指点，在此表示感激不尽。♡♡♡

---

一：重写【override】

1. 什么是重写？

重写是子类对父类允许访问的方法进行重写编写，方法名返回值和形参不变。巧记：外壳不变，核心重写。

/**
 * @author Tornado
 * @date 2021/11/5 16:39
 */
public class Animal {
    public void eat(){
        System.out.println("吃");
    }
}
class Dog extends Animal{
    @Override//方法重写
    public void eat() {
        System.out.println("狗吃肉");
    }
}

2. 思考代码

2.1 例子：思考下面这个程序执行结果☟☟☟

public class AnimalTest {
    public static void main(String[] args) {

        //创建一个对象
        Animal a = new Animal();
        a.eat();  //动物可以吃
        Animal a1 = new Dog();
        //  a1.break();  编译报错，因为编译看左，运行看右。  父类中没有break方法
        a1.eat(); //狗可以吃

    }
}
//定义一个父类Animal
class Animal{
    public void eat(){
        System.out.println("动物可以吃");
    }

}
//定义一个子类dog继承父类Animal
class Dog extends Animal{
    //定义一个吃的方法eat()
    public void eat(){
        System.out.println("狗可以吃");
    }
    //定义一个方法bark()
    public void bark(){
        System.out.println("狗可以叫");
    }
}

执行结果：

结果会抛出一个编译报错，因为Animal中没有bark方法。核心：编译看左，运行看右。

2.2 父类static修饰的方法能被重写吗？

父类static修饰的方法不能被重写，首先弄清楚，重写和继承是多态的前提下。如果能重写，多态父类的引用指向子类的对象，会冲突，不知道调用父类还是子类，所以不能重写。

public class AnimalTest {
    public static void main(String[] args) {

        Animal animal = new Dog();
        animal.sleep();  // 动物可以睡觉

    }
}
//定义一个父类Animal
class Animal{
    public void eat(){
        System.out.println("动物可以吃");
    }

    public static void sleep(){
        System.out.println("动物可以睡觉");
    }
}
//定义一个子类dog继承父类Animal
class Dog extends Animal{
    //定义一个吃的方法eat()
    @Override
    public void eat(){
        System.out.println("狗可以吃");
    }

    //@Override   编译报错 父类中static的方法不能被重写
    public static void sleep(){
        System.out.println("狗也可以睡觉");
    }
}

2.3 子类重写父类，子类权限修饰符要大于等于父类权限

//定义一个父类Animal
class Animal{
    public void eat(){
        System.out.println("动物可以吃");
    }
}

//定义一个子类dog继承父类Animal
class Dog extends Animal{
    //定义一个吃的方法eat()
    //编译报错，因为子类重写父类的方法，子类的权限修饰符要大于等于父类的权限修饰符
   /* @Override
    protected void eat(){
        System.out.println("狗可以吃");
    }*/
}

2.4 子类所有的构造方法第一行默认都有super()；

在继承关系前提下，所有子类的无参构造第一行默认都会有super()关键字，用来访问父类的无参构造。因为子类在创建对象使用的时候，可能会使用父类的内容，所以必须先初始化父类。

public class AnimalTest {
    public static void main(String[] args) {
        //创建Dog对象
        Dog dog = new Dog();
    }
}
//定义一个父类Animal
class Animal{
    public Animal(){
        System.out.println("父类的构造方法");
    }
}

//定义一个子类dog继承父类Animal
class Dog extends Animal{
    public Dog(){
        //默认第一句会有super(),用来调用父类的无参构造
        System.out.println("子类的构造方法");
    }
}

2.5 子类构造方法第一句super()和this()不能共存

因为初始化只能一次，所以super()和this()不能共存。

//定义一个父类Animal
class Animal{
    int a ;
    public Animal(int a){
        this.a = a;
    }
}

//定义一个子类dog继承父类Animal
class Dog extends Animal{
    public Dog(){
        //默认第一句会有super(),用来调用父类的无参构造
        super(12);
        //this(10);  //编译报错，因为父类初始化，只能初始化一次。所以super()和this()不能共存
        System.out.println("子类的构造方法");
        System.out.println(super.a);
    }
}

3. 重写规则：

1. 参数列表必须完全相同

   参数列表必须要和被重写的参数列表完全相同，外壳不变，核心重写

2. 方法名必须完全相同

   重写的方法名必须要和被重写的方法名完全相同，外壳不变，核心重写

3. 返回值必须完全相同

   重写的方法返回值必须要和被重写的方法返回值一致。

4. 子类访问权限不能低于父类访问权限

   子类重写父类的方法时访问权限不能低于父类的访问权限，例如：父类使用public修饰，子类不能使用protected。

5. 声明final的方法不能被重写

   父类中的方法如果使用final关键字，子类继承父类的时候就不能重写。

6. 声明static的方法不能被重写

   如果父类中的方法使用static关键字，则子类不能重写父类的方法。

7. 使用private修饰的方法不能被重写

   父类中如果使用private修饰后，子类不能重写父类的方法。

8. 构造方法不能被重写

   因为构造方法都不能被继承，所以父类中的构造方法不能被子类重写。

9. 不继承的类不能重写方法

   如果一个类没有被继承，则这个类的方法不能被重写。

4. super关键字

• 子类中如果想要使用父类的方法，就需要使用super关键字调用父类的方法。

  举例：

  class Animal{
     public void move(){
        System.out.println("动物可以移动");
     }
  }
   
  class Dog extends Animal{
     public void move(){
        super.move(); // 使用super关键字,调用父类中的move方法
        System.out.println("狗可以跑和走");
     }
  }
   
  public class TestDog{
     public static void main(String args[]){
   
        Animal b = new Dog(); // Dog 对象
        b.move(); //执行Dog类的方法
   
     }
  }
  

  运行结果：

  动物可以移动
  狗可以跑和走
  

二：重载【overload】

1. 什么是重载？

重载是在一个类中，方法名相同，参数列表不同，于返回值没有关系。巧记：名同，参不同。

public void method() {
    System.out.println("这是第一个方法");
}
//方法名相同，参数列表不同,与返回值无关
public int method(int a) {
    return a;
}

2. 重载规则：

1. 被重载的方法必须改变参数列表【个数，类型】

   被重载的方法的参数列表必须要不同，具有独一无二性。不同体现在个数，类型，顺序等。

2. 被重载的方法返回值可以不同

   被重载的方法的返回值可以不相同，可以改变返回值类型。

3. 被重载的方法可以改变访问权限修饰符

   被重载的方法修饰符可以是private，protected，public，重载和方法修饰符无关。

三：重写和重载的区别

区别点	重写方法	重载方法
权限修饰符	有约束	可以修改
返回值	必须相同	可以修改
方法名	必须相同	必须相同
参数列表	必须相同	必须修改

四：总结

方法的重载overload和重写override都是多态性的不同表现

• 重写可以理解是父类和子类之间多态性的一种表现

• 重载可以理解为是一个类中多态性的具体表现形式

• 重写是在子类继承父类时，子类重写父类的方法，重写时返回值类型和方法名和参数列表必须和父类中完全相同且独一无二，这就是方法的重写。可以理解为 外壳相同 ，核心重写。

• 重载时在一个类中，有很多方法名相同，参数列表必须不同，这个不同不仅体现在参数数量上的不同，还有类型，顺序不同。这个称为方法的重载。可以理解为 名同 ，参不同。

不要在最能吃苦的年纪选择了安逸！！！ — Tornado♥