方法重载（overload）和方法覆盖(override)(方法重写[overwrite])的区别

方法的覆盖(override)、重载(overload)和重写(overwrite)

 

• 方法的覆盖(override)、重载(overload)和重写(overwrite)
  • 覆盖（override）
    • Example
    • Output
  • 重载（overload）
    • Example
    • Output
  • 重写（overwrite）
    • Example
    • Output

覆盖（override）

方法覆盖是说子类重新定义了父类的方法。方法覆盖必须有相同的方法名，参数列表和返回类型。

覆盖者可能不会限制它所覆盖的方法的访问。

Example

class Super{
    public void NoParametersMethod(){
        System.out.println("Super Method....");
    }
}

class subClass extends Super {
    public void NoParametersMethod(){
        System.out.println("subClacc Method....");
    }   
}

class override{
    public static void main(String[] args) {
        subClass sub = new subClass();
        sub.NoParametersMethod();
    }
}

 

Output

subClacc Method....

重载（overload）

（1）方法重载是让类以统一的方法处理不同类型数据的一种手段。多个同名函数同时存在，具有不同的参数个数（类型）。重载Override是一个类中多态性的一种表现。

（2）java的方法重载，就是在类中可以创建多个方法，他们具有相同的名字，但具有不同参数和不同的定义。调用方法时通过传递给他们不同的参数个数和参数类型来决定具体使用那个方法，这就是多态性。

（3）重载的时候，方法名要一样，但是参数类型和个数不一样，返回值类型可以相同也可以不同。无法以返回类型来作为重载函数的区分标准。

。

Example

public class Test21 {
    public static void main(String[] args) {
        System.out.println(add(3, 5));// 8
        System.out.println(add(3, 5, 10));// 18
        System.out.println(add(3.0, 5));// 8.0
        System.out.println(add(3, 5.0));// 8.0
        // 我们已经见过的方法的重载
        System.out.println();// 0个参数
        System.out.println(1);// 参数是1个int
        System.out.println(3.0);// 参数是1个double
    }
    /** 求和的方法 */
    public static int add(int n1, int n2) {
        int sum = n1 + n2;
        return sum;
    }
    // 方法名相同，参数个数不同，构成重载
    public static int add(int n1, int n2, int n3) {
        int sum = n1 + n2 + n3;
        return sum;
    }
    // 方法名相同，参数类型不同，构成重载
    public static double add(double n1, int n2) {
        double sum = n1 + n2;
        return sum;
    }
    // 方法名相同，参数顺序不同，构成重载
    public static double add(int n1, double n2) {
        double sum = n1 + n2;
        return sum;
    }
    //编译错误：只有返回值不同，不构成方法的重载
    public static double add(int n1, int n2) {
        double sum = n1 + n2;
        return sum;
    }
    //编译错误：只有参数名称不同，不构成方法的重载
    public static int add(int n2, int n1) {
        double sum = n1 + n2;         
        return sum;
    }  
}

 

 

重写（overwrite）

重写（Overriding）

（1）父类与子类的多态性，对父类的函数进行重新定义。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写。在java中，子类可继承父类的方法，则不需要重新编写相同的方法。但有时子类并不想原封不动继承父类的方法，而是想做一定的修改，这就采用方法重写。方法重写又称方法覆盖。

（2）若子类中的方法与父类的中的某一方法具有相同的方法名、返回类型和参数表，则新方法覆盖原有的方法。如需要父类的原有方法，可以使用super关键字，该关键字引用房钱类的父类。

（3）子类函数访问权限大于父类。

Example

package cn.linxun.oo1;

/*
 * @author Jason
 * 测试重写  
 *    1. ==     方法名，形参列表相同
 *    2.≤       返回值类型和声明异常类型，子类小于等于父类
 *    3.≥       访问权限，子类大于等于父类
 * @author Jason
 */
public class TestOverride {

	public static void main(String[] args) {
		Horse H1 = new Horse();
		H1.run();
		H1.stop();

	}

}

class Vehicle{
	public void run(){
		System.out.println("跑。。。。");
	}
	
	public void stop(){
		System.out.println("没有重写的stop方法，将保持父类的stop");
	}
	
	public Person whoIsPassenage(){//返回乘客
		return new Person();
	}
}


class Horse extends Vehicle{
	public void run(){
		System.out.println("重写的run,跑的飞快。。。");
	}
	
	public Student whoIspassenage(){ //Objcet大于了Person,所以报错
		return new Student();
	}
}

 

 

Output

重写的run,跑的飞快。。。
没有重写的stop方法，将保持父类的stop