重载与重写的区别

重载与重写的区别

一、重载

1. 定义：

方法的重载（overload）:在同一个类中，允许存在一个以上的同名方法，只要他们的参数个数或者参数类型不同即可。

”两同一不同“：同一个类、相同方法名
             参数列表不同，参数个数不同，参数类型不同

2、如何判断重载：

• 跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系！

如下四个方法构成了重载:

public class overload{
      
 public void getSum(int i,int j){
     Ststem.out.println(i+j);
}
  public void getSum(double d1,double d2){
        
}
  public void getSum(String s,int i){
          
}
//方法四与方法三的参数顺序不同，可以构成重载
  public void getSum(int i,String s){
        
}
}

如下四个方法不构成重载:

 public void getSum(int i,int j){
}
//与方法一形参变量名不相同，但形参列表相同，不构成重载
 public void getSum(int m,int n){
}
//与方法一返回值类型不同，但形参列表相同，不构成重载
 public int getSum(int i,int j){
}
//与方法一权限修饰符不同，但形参列表相同，不构成重载
private void getSum(int i,int j){
}

3、在通过对象调用方法时，如何确定某一指定的方法？

• 方法名---->参数列表

overload test=new overload();
 test.getsum(1.0,1.0);//------>调用的是getSum(double d1,double d2)方法`

4、方法的重载小练习

与void show(int a,char b,double c){}构成重载的有：

  a）void show(int x,char y,double z){}            // no
  b)   int   show(int a,double c,char b){}         //yes
  c)   void   show(int a,double c,char b){}        //yes
  d)   boolean  show(int c,char b){}              //yes
  e)   void   show(double c){}                    //yes
  f)   double show(int x,char y,double z){}       //no
  g)   void   shows(double c){}                  //no

二、重写

1. 定义：
在子类中可以根据需要对父类中继承来的方法进行改造，也称为方法的重置、覆盖。在执行程序时，子类的方法可以覆盖父类的方法。

子类继承父类后，可以对父类中同名、同参数的方法，进行覆盖操作

2、要求

1. 子类重写的方法必须和父类被重写的方法具有相同的方法名称、参数列表

2. 子类重写的方法的返回值类型不能大于父类被重写的方法的返回值类型

   ->父类被重写方法的方法的返回值类型是void,则子类重写方法的返回值类型只能是void
   ->父类被重写方法的方法的返回值类型是A类,则子类重写方法的返回值类型可以是A类或A类的子类
   -> 父类被重写方法的方法的返回值类型是基本数据类型（比如：double）,则子类重写方法的返回值类型只能是相同的基本数据类型(必须也是double)
   

3. 子类重写的方法的使用的访问权限不能小于父类被重写的方法的访问权限

4. 子类方法抛出的异常不能大于父类被重写方法的异常

注意：
父类与子类中同名、同参数的方法必须同时声明为非static的（即为重写），或者同时声明为static（不是重写）。因为static方法属于类的，子类无法覆盖父类的方法

三、 区别

重载实现于一个类中;重写实现于子类中。

重载(Overload)：是一个类中多态性的一种表现，指同一个类中不同的函数使用相同的函数名，但是函数的参数个数或类型不同。可以有不同的返回类型;可以有不同的访问修饰符;可以抛出不同的异常。调用的时候根据函数的参数个数或者参数类型的不同来区别不同的函数。

重写（Override): 是父类与子类之间的多态性，是子类对父类函数的重新实现。函数名和参数与父类一样，子类与父类函数体内容不一样。子类返回的类型必须与父类保持一致；子类方法访问修饰符的限制一定要大于父类方法的访问修饰（public>protected>default>private）；子类重写方法一定不能抛出新的检查异常或者比被父类方法申明更加宽泛的检查型异常。
重载(Overload)：

public class Goods {  //创建一个商品类 
private String ID;
private int price;
private String name;
private String manufactureDate;
//实现构造函数的重载 参数个数或类型不同
public Goods() {
	super();
	}
	public Goods(String iD, int price, String name, String manufactureDate) {
	super();
	ID = iD;
	this.price = price;
	this.name = name;
	this.manufactureDate = manufactureDate;
}

public Goods(String iD) {
	super();
	ID = iD;
}
public Goods(String iD, int price) {
	super();
	ID = iD;
	this.price = price;
}
public Goods(String iD, int price, String name) {
	super();
	ID = iD;
	this.price = price;
	this.name = name;
}

}

重写（Override):

public class Person {  //创建一个父类Person
private String name;
private int age;
//父类中写一个eat()方法
	public void eat() {
		System.out.println("人都要吃饭");
		}
}
---------------------------------------------

public class Student extends Person {  //Student子类继承Person父类
@Override
//重写eat()方法   方法名，参数，返回类型相同；方法体内容不同
public void eat() {
	System.out.println("学生喜欢吃零食");
			}
}