java (11)方法的重写和super

1、重写：

在Java和其他一些高级面向对象的编程语言中，子类可继承父类中的方法，而不需要重新编写相同的方法。但有时子类并不想原封不动地继承父类的方法，而是想作一定的修改，这就需要采用方法的重写。方法重写又称方法覆盖。
子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作
2、应用：

​ 重写以后，当创建子类对象以后，通过子类对象调用子父类中的同名同参数的方法时，实际执行的是子类重写父类的方法。

3、重写的规定：

//方法的声明
权限修饰符 返回值类型 方法名（形参列表） throws 异常的类型{
方法体

//方法的声明
权限修饰符   返回值类型    方法名（形参列表）  throws  异常的类型{
                                    方法体
}

 

约定俗称：子类中的叫重写的方法，父类中的叫被重写的方法。
子类重写的方法的方法名和形参列表与父类被重写的方法名和形参列表相同。
子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符。
特殊情况：子类不能重写父类中声明为privite权限的方法。
返回值类型：
父类被重写的方法的返回值类型是void，则子类重写的方法的返回值类型只能是void。
父类被重写的方法的返回值类型是A类型，则子类重写的方法的返回值类型可以是A类或A类的子集。
父类被重写的方法的返回值类型是基本数据类型（比如：double），则子类重写的方法的返回值类型必须是相同的基本数据类型。
子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型。
子类和父类中的同名同参数的方法要么都声明为非static的（考虑重写），要么都声明为static的（不是重写）。
4、super关键字：

super关键字的使用：
在子类的成员方法中，访问父类的成员变量。
在子类的成员方法中，访问父类的成员方法。
在子类的构造方法中，访问父类的构造方法。
super和this关键字的区别：
this在本类的成员方法中，访问本类的成员变量。
this在本类的成员方法中，访问本类的另一个成员方法。
this在本类的构造方法中，访问本类的另一个构造方法。
我们可以在子类的构造器中显式的使用“super（形参列表）”的方式，调用父类中声明的指定的构造器。
“Super(形参列表)”的使用，必须声明在子类构造器的首行。
我们在类的构造器中，针对“this(形参列表)”或者“super(形参列表)”只能二选一，不能同时出现。
在构造器的首行，没有显示的声明“this(形参列表)”或者“super(形参列表)”，则默认调用的是父类中空参的构造器。
在类的多个构造器中，至少有一个类的构造器中使用“super(形参列表)”，调用父类中的构造器。
5、实例：

//父类
package extendsTest;

public class Father {
    private String name;
    private int age;
    private String sex;//性别

    public Father() {
        System.out.println("父亲无处不在");
    }

    public Father(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public void work(){
        System.out.println("父亲要开始工作了");
    }
    public void eat(){
        System.out.println("父亲要吃饭了");
    }
}

//子类
package extendsTest;

public class Son extends Father {
    private String IDcard;

    public Son(){
        super();
    }

    public Son(String name, int age, String sex, String IDcard) {
        super(name, age, sex);//调用父类中的属性
        this.IDcard = IDcard;

    }

    public String getIDcard() {
        return IDcard;
    }

    public void setIDcard(String IDcard) {
        this.IDcard = IDcard;
    }
    public void eat(){
      //eat方法的重写
        System.out.println("儿子要吃饭了");
        super.eat();//调用父类的方法
    }
}

//测试
package extendsTest;

public class Test {
    public static void main(String[] args) {
        Son son=new Son("tom",23,"男","12345678");
        son.eat();
        System.out.println("IDcard="+son.getIDcard()+",name="+son.getName()+",age="+son.getAge()+",sex="+son.getSex());
        Son son2=new Son();


    }
}

 

重载

重载(overloading) 发生在本类。
定义：方法名必须一致，参数列表必须不同（参数的个数或类型不同），返回值类型可以相同也可以不同。即定义在同一类中的两个或多个方法同名但不同参，这就叫做方法的重载。

package day_11_26;

/**
 * @author soberw
 */
public class Overloading {

    /**
     * 以下方法构成重载
     */
    //初始方法
    public void sum() {

    }
    //构成重载，因为参数列表不同
    public void sum(int i) {

    }
    //报错,因为参数列表相同
//    public void sum(int a){
//
//    }

    //构成重载，因为参数类型不同
    public void sum(String i) {

    }
    //报错  重载跟方法有无返回值无关系
//    public int sum(int i){
//
//    }
    //构成重载 ，因为参数列表和长度都不同
    public void sum(int i,int j){

    }
    //报错 重载与修饰符无关
    protected void sum(int i){
        
    }
}