重写和重载

重载（Overloading）

重载发生在本类,方法名相同,参数列表不同,与返回值无关,只和方法名,参数列表,参数的类型有关.

重载（Overload）:首先是位于一个类之中或者其子类中，具有相同的方法名，但是方法的参数不同，返回值类型可以相同也可以不同。

（1）：方法名必须相同

（2）：方法的参数列表一定不一样。

（3）：访问修饰符和返回值类型可以相同也可以不同。

其实简单而言：重载就是对于不同的情况写不同的方法。 比如，同一个类中，写不同的构造函数用于初始化不同的参数。

public class Test1 {
    public void out(){
        System.out.println("参数"+null);
    }
    //参数数目不同
    public void out(Integer n){
        System.out.println("参数"+n.getClass().getName());
    }
 
    //参数类型不同
    public void out(String string){
        System.out.println("参数"+string.getClass().getName());
    }
 
    public void out(Integer n ,String string){
        System.out.println("参数"+n.getClass().getName()+","+string.getClass().getName());
    }
    //参数顺序不同
    public void out(String string,Integer n){
        System.out.println("参数"+string.getClass().getName()+","+n.getClass().getName());
    }
    
    public static void main(String[] args) {
        Test1 test1 = new Test1();
        test1.out();
        test1.out(1);
        test1.out("string");
        test1.out(1,"string");
        test1.out("string",1);
    }
}
 

重写

一、什么是重写？

1. 重写(Override)概念
   重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！

重写发生在父类子类之间,比如所有类都是继承与Object类的,Object类中本身就有equals,hashcode,toString方法等.在任意子类中定义了重名和同样的参数列表就构成方法重写.

重写的好处在于子类可以根据需要，定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法。

重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如： 父类的一个方法申明了一个检查异常 IOException，但是在重写这个方法的时候不能抛出 Exception 异常，因为 Exception 是 IOException 的父类，只能抛出 IOException 的子类异常。

2. 个人理解：
   在子类中可以根据需要对从基类中继承来的方法进行重写，重写是对类中方法的扩充，因为继承用的是父类的东西，重写则不仅得到父类的东西，同时也加入了自己的东西

3. 官方理解：
   在Java和其他一些高级面向对象的编程语言中，子类可继承父类中的方法，而不需要重新编写相同的方法。但有时子类并不想原封不动地继承父类的方法，而是想作一定的修改，这就需要采用方法的重写。方法重写又称方法覆盖。若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表，则新方法将覆盖原有的方法。 如需父类中原有的方法，可使用super关键字，该关键字引用了当前类的父类。

二、方法重写的一些特性：

1）：方法名必须相同，返回值类型必须相同

（2）：参数列表必须相同

（3）：访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为public，那么在子类中重写该方法就不能声明为protected。

（4）：子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为private和final的方法。

（5）：构造方法不能被重写，

简单而言：就是具体的实现类对于父类的该方法实现不满意，需要自己在写一个满足于自己要求的方法。

1.发生方法重写的两个方法返回值、方法名、参数列表必须完全一致(子类重写父类的方法)
2.子类抛出的异常下不能超过父类相应方法抛出的异常(子类异常不能大于父类异常)
3.子类方法的访问级别不能低于父类相应方法的访问级别(子类访问级别不能低于父类访问级别)
根据2，3条可以确定第一条，子类重写父类方法的返回值类型不能大于父类方法的返回值类型，即是说子类方法的返回值必 须和父类方法的返回值相同或是其子类。

（1） 父类与子类之间的多态性，对父类的函数进行重新定义。即在子类中定义某方法与其父类有相同的名称和参数。
（2）若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表，则新方法将覆盖原有的方法。如需父类中 原有的方法，可使用super关键字，该关键字引用了当前类的父类。
注意：方法重写与方法重载不同，方法的重载是方法的参数个数或种类或顺序不同，方法名相同。

三、重写示例

父类Animal

package com.example.demo.entity;
 
/**
 * @desc:  父类Animal
 * @author: cao_wencao
 * @date: 2020-11-19 10:07
 */
public class Animal {
 
    public void move(){
        System.out.println("狗可以跑和走");
    }
 
}

子类Cat重写父类move()方法

package com.example.demo.entity;
 
/**
 * @desc:  子类Cat重写Animal的move()方法
 * @author: cao_wencao
 * @date: 2020-11-19 10:11
 */
public class Cat extends Animal{
 
    public void move(){
        super.move();
        System.out.println("猫可以跳、可以吃小鱼");
    }
}
TestAnimal
package com.example.demo.entity;
 
/**
 * @desc:
 * @author: cao_wencao
 * @date: 2020-11-19 10:13
 */
public class TestAnimal {
    public static void main(String[] args) {
        Animal animal = new Animal(); // Animal 对象
        Animal cat = new Cat(); // Cat 对象
 
        //animal.move();// 执行 Animal 类的方法
 
        cat.move();//执行 Cat 类的方法
    }
 
}

结果如下：

狗可以跑和走
猫可以跳、可以吃小鱼

四、重写的作用？

重写是为了增强类的重用性和复用性，扩展性；

重写是对类中方法的扩充，因为继承用的是父类的东西，重写则不仅得到父类的东西，同时也加入了自己的东西，两全其美。

重写ToString
首先，我们先来创建一个Persion类，它只简单的包含name和sex、city、site这4个属性，当然，生成它的setter 和 getter 法。

public class Person {
    private String name;
    private String sex;
    private String city;
    private String site;
 
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public String getCity() {
        return city;
    }
    public void setCity(String city) {
        this.city = city;
    }
    public String getSite() {
        return site;
    }
    public void setSite(String site) {
        this.site = site;
    }    

}
接下来，新建一个类，名为Test，让它包含main函数：

import com.yingjun.ssm.entity.Person;
/**
 * <pre>
 * @Desc 
 * @author cao_wencao
 * @date 2019年4月28日 下午1:48:49
 * @version V1.0
 * </pre>
 */
public class Test {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Person person = new Person();
        person.setName("Thinkingcao");
        person.setSex("男");
        person.setCity("上海");
        person.setSite("https://thinkingcao.blog.csdn.net");
        System.out.println(person.toString());
    }
}

可以看到，运行之后，结果为： com.yingjun.ssm.entity.Person@6d06d69c

注：打印一个对象，可以直接System.out.println(persion);其实println方法内部会自动调用persion的 toString() 方法。

但是，我们一般想要的结果并不是这样，因为Object类的toString()方法总是返回对象的所属类的类名 + @ + hashCode值，代表对象在内存的位置。这显然不能满足我们通常的需求。像这里，我们是希望能打印出persion的全名出来，这时，就需要重写toString()方法，因为重写了toString()之后，那么persion在调用toString()方法的时候，会优先调用自己类里的toString()方法。可自行回顾多态知识点
修改后的类如下：

public class Person {
    private String name;
    private String sex;
    private String city;
    private String site;
 
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public String getCity() {
        return city;
    }
    public void setCity(String city) {
        this.city = city;
    }
    public String getSite() {
        return site;
    }
    public void setSite(String site) {
        this.site = site;
    }
    // 重写toString方法
    @Override
    public String toString() {
        return "Person [name=" + name + ", sex=" + sex + ", city=" + city + ", site=" + site + "]";
    }        
 
}

这时，打印出来的结果就是 : Person [name=Thinkingcao, sex=男, city=上海, site=https://thinkingcao.blog.csdn.net]
当然，可根据不同的需求来重写toString方法。