重载Java函数示例：如何实现多态？

在Java中，函数重载是指在一个类中声明多个同名的方法，但这些方法的参数列表不同。Java通过参数列表的不同来区分不同的函数，从而实现函数重载。

实现函数重载有以下几个步骤：

1. 声明多个同名方法，但参数列表要不同。参数列表可以通过参数的类型、个数和顺序来区分。例如，一个类中可以有两个同名的方法：add(int a, int b)和add(double a, double b)。

2. 调用方法时，根据传入的参数来自动选择调用哪个方法。Java编译器根据参数的类型来匹配合适的方法。如果找到完全匹配的方法，则调用该方法；如果找不到完全匹配的方法，但找到了能够自动转换参数类型匹配的方法，则调用该方法；如果找不到匹配的方法，则会报编译错误。

以下是一个函数重载的示例代码：

public class OverloadExample {
    public static void add(int a, int b) {
        int sum = a + b;
        System.out.println("Sum of integers: " + sum);
    }
    
    public static void add(double a, double b) {
        double sum = a + b;
        System.out.println("Sum of doubles: " + sum);
    }
    
    public static void add(String a, String b) {
        String concat = a + b;
        System.out.println("Concatenation of strings: " + concat);
    }
    
    public static void main(String[] args) {
        add(1, 2); // 调用add(int a, int b)方法
        add(1.5, 2.5); // 调用add(double a, double b)方法
        add("Hello, ", "World!"); // 调用add(String a, String b)方法
    }
}

在上面的示例中，我们定义了三个同名的add方法，但参数列表分别是int类型、double类型和String类型。然后，在main方法中进行了三次调用，分别传入了不同类型的参数。Java编译器会根据传入的参数自动选择调用相应的方法。

多态是面向对象编程中的一个重要概念，它使得一个对象能够以多种类型的形式存在。在Java中，多态是通过继承和接口实现的。

在前面的示例中，使用了静态方法，静态方法不能实现多态。要实现多态，需要使用实例方法和继承。

假设我们有一个父类Animal和它的两个子类Dog和Cat。我们定义一个实例方法makeSound来输出动物发出的声音：

public class Animal {
    public void makeSound() {
        System.out.println("Animal makes sound");
    }
}

public class Dog extends Animal {
    public void makeSound() {
        System.out.println("Dog barks");
    }
}

public class Cat extends Animal {
    public void makeSound() {
        System.out.println("Cat meows");
    }
}

public class PolymorphismExample {
    public static void main(String[] args) {
        Animal animal = new Animal();
        Dog dog = new Dog();
        Cat cat = new Cat();
        
        animal.makeSound(); // Animal makes sound
        dog.makeSound(); // Dog barks
        cat.makeSound(); // Cat meows
        
        Animal animal1 = new Dog();
        animal1.makeSound(); // Dog barks
        
        Animal animal2 = new Cat();
        animal2.makeSound(); // Cat meows
    }
}

在上面的示例中，Animal是父类，而Dog和Cat是子类。通过创建Animal、Dog和Cat的实例，我们可以调用它们的makeSound方法。当我们调用animal1.makeSound()时，animal1是Animal类型的变量，但它引用的是Dog类型的对象，因此会调用Dog类中重写的makeSound方法，即输出"Dog barks"。同样地，当我们调用animal2.makeSound()时，animal2是Animal类型的变量，但它引用的是Cat类型的对象，因此会调用Cat类中重写的makeSound方法，即输出"Cat meows"。

通过继承和重写方法，我们可以实现多态，即一个对象能够以多种不同的类型存在，并根据调用方法时的实际类型来决定执行哪个方法。这是面向对象编程中的一个重要特性，能够提高代码的灵活性和可扩展性。