重载和覆盖重写

一. 什么是重载：

              重载即在同一个类中，方法名称相同，参数列表不同（参数列表的顺序不同或者参数列表的个数不同）的方法，称为重载。

 

二. 重载的例子：构造器的重载

public class OverloadDemo {
    private String name;
    private int age;
    private double score;

    public OverloadDemo() {
        System.out.println("无参构造器");
    }

    public OverloadDemo(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("两个参数的构造器");
    }

    public OverloadDemo(String name, int age, double score) {
        this.name = name;
        this.age = age;
        this.score = score;
        System.out.println("三个参数的构造器");
    }

    public static void main(String[] args) {
        /**
         * 通过构造器的重载，可以根据实际情况来选择对应的构造器创建对象并初始化数据。
         */
       OverloadDemo demo = new OverloadDemo();  //调用无参构造器
       OverloadDemo demo1 = new OverloadDemo("张三",23);  //调用两个参数的构造器
       OverloadDemo demo2 = new OverloadDemo("张三",23,100);  //调用三个参数的构造器
    }
}

三. 重载的优点：

         1. 方法重载可以定义相同的方法名，方便阅读。

         2. 优化程序，使得编写代码更少。

         

四. 重载的特点：

         1. 方法重载必须要在同一个类中。

         2. 重载必须方法名相同，参数不同（即参数的列表不同，参数的顺序不一致，与参数的名称无关）

         3. 与修饰符和返回值类型无关。

 

五. 重载的一个小练习：

public class OverloadDemo {
    public static byte num =9;
    public static char index = '9';

    public static void show(byte num){
        System.out.println("byte:"+num);
    }
    public static void show(short num){
        System.out.println("short"+num);
    }
    public static void show(char num){
        System.out.println("char："+num);
    }
    public static void show(Byte num){
        System.out.println("int:"+num);
    }
    public static void show(Character num){
        System.out.println("Character:"+num);
    }
    public static void show(Integer num){
        System.out.println("int:"+num);
    }

    public static void main(String[] args) {
        show(num);    
        show(index);
    }

}

        输出结果：

        char类型遵循的结果为：char-->int-->long-->float-->double-->Character(跟自己类型匹配的包装类型)

        基本数据类型遵循的结果： byte-->short-->int-->long-->float-->double-->(跟自己类型匹配的包装类型（自动装箱）)

        比如说：把byte传参的方法注释掉,则会输出short9;其他同理

                      把所有的原始数据类型传参的方法注释掉，唯独留下char、Character、Integer传参的方法，在传一个字符的数据，打印的结果cahr:57,接着再注释上次打印所属的方法。再次打印得，Character：9,同上一步，最后报错。

 

六. 重写的概述：

        重写是指在子类和父类中具有相同的方法名称，相同的返回值类型和参数列表，方法体可以不一样。

 

七. 重写的例子（继承中）：

         1. 创建Father类：

public class Father {
    private String name;
    private int age;

    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 void mehtod(){
        System.out.println("父类的method方法");
    }

    int message(int age){
        System.out.println("父类的年龄："+age);
        return age;
    }
}

          2. 创建Son类继承Father类：

public class Son extends Father {
    // 注意成员的属性不能被覆盖重写
    //@Override   会报错  
    private String name;
    private int age;

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

    @Override
    public void mehtod() {
        System.out.println("子类的method方法");
    }

    @Override
    //子类的修饰符大于父类的修饰符
    public int message(int age) {
        System.out.println("子类的年龄："+age);
        return age;
    }
}

          3. 测试方法：

public class TestMain {
    public static void main(String[] args) {
        Son son = new Son("tom",16);
        son.mehtod();   //输出 子类的method方法 （父类的方法被覆盖重写）
        son.message(16);  //输出 子类的年龄：16
    }

}

八：重写的特点：

           1. 必须发生在子父类中

           2. 子父类中必须要有相同的方法名称，相同的参数列表及其顺序结构，返回值类型要一致

           3. 子类的修饰符必须要大于父类的参数名称

           4. 父类的修饰符不能为private修饰

           5. 当子类访问的方法或者成员变量不在子类当中时，便会向上寻找。