Java中的重载、重写和重构的区别

Love The Way You Lie 2021-09-17 08:12 469阅读 0赞

# 1、重载 #

重载（overloaded）： 重载就是在同一个类中允许同时存在一个以上的同名方法，只要这些方法的参数个数或类型不同即可。

我们知道构造方法的名称已经由类名决定，所以构造方法只有一个名称，但如果希望以不同的方式来实例化对象，就需要使用多个构造方法来完成。由于这些构造方法都需要根据类名进行命名，为了让方法名相同而形参不同的构造方法同时存在，必须用到“方法重载”，虽然方法重载起源于构造方法，但是它也可以应用到其他方法中。

**示例：**在项目中创建OverLoadTest类，在类中编写add()方法的多个重载形式，然后在主方法中分别输出这些方法的返回值。

/**
     * 重载示例
     * 
     * @author pan_junbiao
     *
     */
    public class OverLoadTest
    {
    	public static int add(int a, int b)
    	{
    		return a + b;
    	}
    
    	public static int add(int a, int b, int c)
    	{
    		return a + b + c;
    	}
    
    	public static double add(double a, double b)
    	{
    		return a + b;
    	}
    
    	/**
    	 * 定义不定长参数方法
    	 */
    	public static int add(int... a)
    	{
    		int s = 0;
    		for (int i = 0; i < a.length; i++)
    		{
    			s += a[i];
    		}
    		return s;
    	}
    
    	public static void main(String[] args)
    	{
    		System.out.println("调用add(int,int)方法：" + add(1, 2));
    		System.out.println("调用add(int,int,int)方法：" + add(1, 2, 3));
    		System.out.println("调用add(double,double)方法：" + add(2.1, 3.5));
    		// 调用不定长参数方法
    		System.out.println("调用不定长参数方法：" + add(1, 2, 3, 4, 5, 6, 7, 8, 9));
    		System.out.println("调用不定长参数方法：" + add(1, 2));
    	}
    }

**执行结果：**

![20200407094944819.jpg][]

**注意：**虽然在方法重载中可以使用两个方法的返回类型不同，但只有返回类型不同并不足以区分两个方法的重载，还需要通过参数的个数以及参数的类型来设置。

**重载的规则：**

（1）必须具有不同的参数列表。

（2）可以有不同的返回类型，只要参数列表不同就可以了。

（3）可以有不同的访问修饰符。

（4）可以抛出不同的异常。

# 2、重写 #

重写（override）：重写（还可以称为覆盖）就是在子类中将父类的成员方法的名称保留，重写成员方法的实现内容，更改成员方法的存储权限，或是修改成员方法的返回值类型（注意：重写父类成员方法的返回值类型是基于J2SE 5.0版本以上编译器提供的新功能）。

**示例：**在项目中创建Parent类和Children类，在Parent类中编写成员方法doSomething()和doIt()，使Children类继承Parent类，重写父类的这两个方法和构造方法，并新增doSomethingNew()方法。其中Children类的构造方法中使用super关键字调用父类的构造方法和成员方法等。

（1）创建Parent父类：

/**
     * 父类
     * 
     * @author pan_junbiao
     *
     */
    public class Parent
    {
    	/**
    	 * 构造方法
    	 */
    	public Parent()
    	{
    		System.out.println("父类构造方法！");
    	}
    
    	/**
    	 * 成员方法
    	 */
    	protected void doSomething()
    	{
    		System.out.println("父类方法");
    	}
    
    	/**
    	 * 成员方法,返回类型为Parent类型
    	 */
    	protected Parent doIt()
    	{
    		return new Parent();
    	}
    }

（2）创建Children子类，并继承父类：

/**
     * 子类
     * 
     * @author pan_junbiao
     *
     */
    public class Children extends Parent // 继承父类
    {
    	/**
    	 * 构造方法
    	 */
    	public Children()
    	{
    		// 调用父类构成方法
    		super();
    
    		// 调用父类成员方法
    		super.doSomething();
    
    		// 子类构造方法
    		System.out.println("子类构造方法");
    	}
    
    	/**
    	 * 子类新增方法
    	 */
    	public void doSomethingNew()
    	{
    		System.out.println("子类新增方法");
    	}
    
    	/**
    	 * 重写父类方法
    	 */
    	public void doSomething()
    	{
    		System.out.println("子类重写父类方法");
    	}
    
    	/**
    	 * 重写父类方法，返回类型为Children类型
    	 */
    	protected Children doIt()
    	{
    		return new Children();
    	}
    }

子类重写父类的方法还可以修改方法的返回值类型，但这只是在J2SE 5.0以上的版本中支持的新功能。示例中子类中的doIt()方法就使用了这个新功能，父类中的doIt()方法的返回值类型为Parent类，而子类中的doIt()方法的返回值类型为Children类，子类中重写了父类的doIt()方法。这种重写方式需要遵循一个原则，即重写的返回值类型必须是父类中同一方法返回值类型的子类，而Children类正是Parent类的子类。

**注意：**当重写父类方法时，修改方法的修饰权限只能从小的范围到大的范围改变，例如，父类中的dosomething()方法的修饰权限为protected，继承后子类中的方法doSomething()的修饰权限只能修改为public，不能修改为private。

**重写的规则：**

（1）参数列表必须完全与被重写的方法相同，否则不能称其为重写而是重载。

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

（3）重写方法一定不能抛出新的检查异常或者比被重写方法申明更加宽泛的检查型异常。例如：父类的一个方法申明了一个检查异常IOException，在重写这个方法是就不能抛出Exception，只能抛出IOException的子类异常，可以抛出非检查异常。

# 3、重构 #

重构：是重写的一种特殊方式，子类与父类的成员方法的返回值、方法名称、参数类型及个数完全相同，唯一不同的是方法实现内容，这种特殊重写方式被称为重构。

[20200407094944819.jpg]: /images/20210724/47ce5f50891e4633aa68907efa41e3c8.png