【软件构造】Override（重写）与Overload（重载）

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

前言

在学习完OOP（面向对象编程）后，我学会了重写和重载的作用和区别，下面对它们进行简单介绍和比较。

---

一、Override（重写）

1. 定义

根据父类中的一个方法，在子类中创建一个与父类的这个方法名称相同、返回值类型相同、参数列表相同的一个方法，只不过方法体中的实现不同，以实现不同于父类的功能，这种方式被称为方法重写(override).

2.例子

我们来举例，来更好的理解什么是重写。
首先我们来创建一个父类Animal。

public class Animal {
	public static void shout() {
		System.out.println("动物都会叫！");
	}

	public final void run() {
		System.out.println("动物都会跑！");
	}

	public void eat(String food) {
		System.out.println("动物都会吃" + food);
	}
}

在父类里，我们定义了三个方法，shout,run,eat。这里注意，shout为静态方法（static），run和eat为成员方法，并且run用final修饰。
在创建一个子类Dog继承父类Animal。

public class Dog extends Animal{

	public static void shout() {
		System.out.println("小狗会汪汪叫！");
	}

	@Override
	public void eat(String food) {
		System.out.println("小狗会吃" + food);
	}
}	

在子类Dog中我们对父类的两个方法进行了重写，就如上面的代码所示，子类中重写的方法与父类方法的名称，返回值，参数列表都相同，只是方法内的实现不同。注意到，对run方法没有重写，是因为run方法被final修饰，不能被重写。
在写一个客户端代码进行测试。

public static void main(String[] args) {
		Dog a = new Dog();
		Animal b = new Dog();
		Animal c = new Animal();
		String str = "骨头";
		a.eat(str);
		b.eat(str);
		c.eat(str);
		a.shout();
		b.shout();
		c.shout();
	}

我们创建了三个新的对象，要注意的是Animal b = new Dog()，含义是父类的引用指向了子类，b调用成员方法时依旧是调用子类的方法，但调用静态方法时是父类的方法。下面是输出结果。

小狗会吃骨头
小狗会吃骨头
动物都会吃骨头
小狗会汪汪叫！
动物都会叫！
动物都会叫！

3.注意事项

1.重写只跟成员方法有关，跟静态方法（static）无关，但在子类中依旧可以声明一个相同的静态方法。
Animal b = new Dog();
对于静态方法，方法的调用只和左边声明的对象类型（Animal）有关，而与右边无关，是哪个类型，就调用对应的方法。
对于成员方法，方法的调用和左边声明的对象类型（Animal）无关，只与右边有关（Dog），是哪个类型，就调用对应的方法。
2.声明为 final 的方法不能被重写。
子类和父类在同一个包中时，子类可以重写父类除了声明为 private 和 final 方法的其他方法。
子类和父类不在同一个包中时，子类只能重写父类的声明为 public 和 protected 的非 final 方法。
3.重写的方法可以用@override标识，编译器会检查这个方法的签名和父类是否相同。
4.重写的时候不要改变父类方法的本意。

二、Overload（重载）

1.定义

在同一个类中，多个方法具有相同的名字，但有不同的参数列表。

2.例子

我们创建了一个Add类，对里面的add方法进行了重载。

public class Add {
  public static int add(int a,int b) {
	  System.out.println("这是方法int");
	  return a + b;
  }
  public static double add(double a,double b) {
	  System.out.println("这是方法double");
	  return a + b;
  }
}

写一个客户端代码进行测试。

public static void main(String[] args) {
	  int a = 4;
	  int b = 2;
	  double x = 1.1;
	  double y = 1.5;
	  System.out.println(add(a,b));
	  System.out.println(add(x,y));
  }

测试结果
这是方法int
6
这是方法double
2.6

3.注意事项

1.方法重载必须参数列表不同，而返回值类型，访问权限（public,private），异常可以相同，也可以不同。
2.方法可以是同一个类中的，也可以对父类的方法进行重载。

三、重写和重载比较

1 例子

我们以一个例子来对重写和重载进行比较。
首先是父类Animal

public void eat(String food) {
		System.out.println("动物都会吃" + food);
	}

然后是子类Dog

@Override
	public void eat(String food) {
		System.out.println("小狗会吃" + food);
	}
	
	public void eat() {
		System.out.println("小狗会吃肉");
	}

在子类中有两个eat方法，第一个是对父类的重写（方法的名称，返回值，参数列表相同），另一个是对eat的重载（方法的参数列表不同）。
对其进行测试

public static void main(String[] args) {
		Dog a = new Dog();
		Animal b = new Dog();
		Animal c = new Animal();
		String str = "骨头";
		a.eat(str);//重写，继承父类方法
		a.eat();//重载
		b.eat(str);//调用子类的方法，这个方法继承自父类
		b.eat();//错误
		c.eat(str);//调用父类方法
		c.eat();//错误
	}

在进行编译的时候，提示我们b.eat()和c.eat()出错。首先是c.eat()，因为c是Animal类的，类中并没有eat()方法，只有eat(String food)方法。
而对于b，它的声明是Animal b = new Dog()；
类如父类 xx = new 子类（），xx只能调用子类的方法，但这个方法必须是继承自父类（Animal）的方法。
eat()方法不是继承父类的，所以不能调用eat()方法。
除去这两句，我们看剩余的输出。

小狗会吃骨头
小狗会吃肉
小狗会吃骨头
动物都会吃骨头

2 比较

1.重写时父类和子类的方法具有相同的签名。
2.当签名不同时，为重载。
3.重载和重写都是实现多态的方式，区别在于前者实现的是编译时的多态性，而后者实现的是运行时的多态性。