java中重写方法 java重写方法什么意思

转载

mob64ca140b466e 2023-08-08 15:48:36

文章标签 java中重写方法 java 父类子类 System 文章分类 Java 后端开发

Java 方法的重写和重载

其实在之前的有些例子中我们已经见过了方法的重写和重载，这里做个简单的总结：

重写（Override）

重写是指子类对父类中可访问的方法的实现过程进行重写，返回值和形参以及修饰符都不能变。
重写的意义在于子类可以根据需要定义特定于自己的行为。也就是说子类可以根据自己的需要实现父类的方法。
重写方法不能抛出新的检查异常或者声明更加宽泛的异常。

//父类Person
public class Person {
    public String name;
    public String gander;
    public int age;
    public String className;

    public void say() {
        System.out.println(
                "My name is" + name + ", gander is " + gander + ", age is " + age + ", class name is" + className);
    }

    public Person(String name, String gander, int age) {
        this.name = name;
        this.gander = gander;
        this.age = age;
        this.className = "PERSON";
    }

    public static void main(String[] args) {
        Person joey = new Person("Joey", "Male", 18);
        joey.say(); // My name isJoey, gander is Male, age is 18, class name isPERSON
    }
}
//子类Chinese
public class Chinese extends Person {
    public Chinese(String name, String gander, int age) {
        super(name, gander, age);
    }

    public void say() {
        System.out.println("Chinese 重写的say方法");
        super.say(); // 调用父类的say方法
    }

    public void eat() {
        System.out.println("Eating...");
    }

    public static void main(String[] args) {
        Chinese hanshufei = new Chinese("Hanshufei", "男", 18);
        Person joey = new Chinese("joey", "female", 20);
        hanshufei.say();
        // Chinese 重写的say方法
        // My name isHanshufei, gander is 男, age is 18, class name isPERSONON
        hanshufei.eat();
        joey.say();
        // Chinese 重写的say方法
        // My name joey, gander is female, age is 20, class name isPERSONON
        // joey.eat();// 报错 因为joey虽然是new Chinese生成的，但是它的类型被定义为了Person， person是没有eat方法的
    }
}

比如这个实例中，子类 Chinese 就重写了父类 Person 的 say 方法。这里需要注意：
joey 虽然是 chinese 的实例，但是他的类型被定义为 Person 而不像 hanshufei 一样被定义为 Chinese，因此 hanshufei 可以调用 chinese 类的 eat 方法而 joey 不可以，因为 Person 类没有 eat 方法。而且还需注意：joey 虽然是 Person 类型但是他调用 say 方法的时候调用的是 Chinese 类的 say 方法，因为他始终是 Chinese 类的实例，只是类型符合 Person 实例。

方法重写规则

参数列表与被重写方法的参数列表必须完全相同。
返回类型与被重写方法的返回类型可以不相同，但是必须是父类返回值的派生类（java5 及更早版本返回类型要一样，java7 及更高版本可以不同）。
访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为 public，那么在子类中重写该方法就不能声明为 protected。
父类的成员方法只能被它的子类重写。
声明为 final 的方法不能被重写。
声明为 static 的方法不能被重写，但是能够被再次声明。
子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为 private 和 final 的方法。
子类和父类不在同一个包中，那么子类只能够重写父类的声明为 public 和 protected 的非 final 方法。
重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。
构造方法不能被重写。
如果不能继承一个类，则不能重写该类的方法。

重载（Overload）

重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。
每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。
最常用的地方就是构造器的重载。
重载规则:

被重载的方法必须改变参数列表(参数个数或类型不一样)；
被重载的方法可以改变返回类型；
被重载的方法可以改变访问修饰符；
被重载的方法可以声明新的或更广的检查异常；
方法能够在同一个类中或者在一个子类中被重载。
无法以返回值类型作为重载函数的区分标准。
例如前面的例子：

// Methods类
public class Mthods {
    public static int getMaxValueFn(int[] arr) {
        int maxValue = arr[0];
        for (int num : arr) {
            if (num > maxValue) {
                maxValue = num;
            }
        }
        return maxValue;
    }

    public static int add(int a, int b) {
        System.out.println("Int Add fn called");
        return a + b;
    }

    public static String add(String a, String b) {
        System.out.println("String Add fn called");
        return a + b;
    }
}
//Funcs类
public class Funcs {
    public static void main(String[] args) {
        int[] arr = { 1, 5, 9, 5, 23, 65, 4 };
        int maxValue = Mthods.getMaxValueFn(arr);
        System.out.println(maxValue); // 65
        // 测试方法重载
        int num1 = 10, num2 = 11;
        System.out.println(Mthods.add(num1, num2)); // 21
        System.out.println(Mthods.add("abc", "def")); // abcdef
    }
}

在这个例子中其实 Methods 的静态方法 add 就实现了重载，调用的时候传入不同类型的参数调用不同的 add 方法。

重写和重载的区别

区别	重载	重写
参数列表	必须修改	不能修改
返回类型	可以修改	不能修改
异常	可以修改	可以减少或删除，不能抛出新的或者更广的异常
访问	可以修改	不变或者只降低限制